typedef long unsigned int size_t;
     typedef long int ptrdiff_t;
   
    
     
   
    extern "C" 
   typedef signed int __int32_t;
   typedef signed long int __int64_t;
   typedef __int32_t __int_least32_t;
   typedef __int64_t __int_least64_t;
   typedef long int __intmax_t;
   typedef struct 
   
   __fsid_t;
   typedef long int __time_t;
    
   extern "C" {
   typedef __int32_t int32_t;
   struct timeval ;;
   typedef long int __fd_mask;
   typedef struct   {
     }
   fd_set;
   typedef struct __pthread_internal_list {}
   __pthread_list_t;
   typedef struct __pthread_internal_slist 
   __pthread_slist_t;
   typedef union 
   pthread_mutex_t;
   typedef union 
   pthread_cond_t;
   typedef union 
   pthread_rwlock_t;
   typedef union 
   
   pthread_barrierattr_t;
   }
   struct drand48_data   ;;
   
    typedef __int_least64_t int_least64_t;
    typedef __intmax_t intmax_t;
    namespace boost {
     using ::int32_t;
     using ::intmax_t;
   }
    
     template<typename>     class allocator;
   
    typedef struct 
    __mbstate_t;
    typedef __mbstate_t mbstate_t;
    
    extern "C++" {
   
     class exception   {};
   
   }
    
     template<typename _Tp, _Tp __v>     struct integral_constant     {};
     typedef integral_constant<bool, true> true_type;
     typedef integral_constant<bool, false> false_type;
     template<bool __v>     using __bool_constant = integral_constant<bool, __v>;
     template <typename _Type>     struct __type_identity     ;;
     template<typename...>     struct __or_;
     template<typename...>     struct __and_;
     template<typename _Pp>     struct __not_     : public __bool_constant<!bool(_Pp::value)>     {};
     template<typename>     struct is_function;
     template<typename>     struct is_void;
     template <typename _Tp, size_t = sizeof(_Tp)>     constexpr true_type __is_complete_or_unbounded()     ;
     template<typename _Tp>     struct __success_type     ;
     struct __failure_type   ;
     template<typename>     struct remove_cv;
     template<typename _Tp>     using __remove_cv_t = typename remove_cv<_Tp>::type;
     template<typename>     struct __is_integral_helper     : public false_type {
   };
     template<typename _Tp>     struct is_integral     : public __is_integral_helper<__remove_cv_t<_Tp>>::type     {
   };
     template<typename>     struct __is_floating_point_helper     : public false_type {};
     template<typename _Tp>     struct is_floating_point     : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type     {
   };
     template<typename>     struct is_array     : public false_type {};
     template<typename>     struct __is_pointer_helper     : public false_type {};
     template<typename _Tp>     struct is_pointer     : public __is_pointer_helper<__remove_cv_t<_Tp>>::type     {};
     template<typename>     struct is_lvalue_reference     : public false_type {};
     template<typename>     struct is_rvalue_reference     : public false_type {
   };
     template<typename _Tp>     struct is_enum     : public integral_constant<bool, __is_enum(_Tp)>     {
   };
     template<typename>     struct __is_null_pointer_helper     : public false_type {};
     template<typename _Tp>     struct is_null_pointer     : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type     {
   };
     template<typename _Tp>     struct __is_nullptr_t     : public is_null_pointer<_Tp>     {
   }
   __attribute__ (());
     template<typename _Tp>     struct is_reference     : public __or_<is_lvalue_reference<_Tp>,                    is_rvalue_reference<_Tp>>::type     {
   };
     template<typename _Tp>     struct is_arithmetic     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type     {};
     template<typename>     struct is_member_pointer;
     template<typename _Tp>     struct is_scalar     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type     {};
     template<typename...> using __void_t = void;
     template<typename _Tp, typename = void>     struct __is_referenceable     : public false_type     {};
     template<typename _Tp>     struct is_trivially_copyable     : public integral_constant<bool, __is_trivially_copyable(_Tp)>     {};
     template<typename _Tp>     struct is_standard_layout     : public integral_constant<bool, __is_standard_layout(_Tp)>     {};
     template<typename _Tp>     struct is_literal_type     : public integral_constant<bool, __is_literal_type(_Tp)>     {};
     template<typename _Tp, typename _Up = _Tp&&>     _Up     __declval;
     template<typename _Tp>     auto declval() noexcept -> decltype(__declval<>());
     template<typename, unsigned = 0>     struct extent;
     template<typename>     struct remove_all_extents;
     template<typename _Tp>     struct __is_array_unknown_bounds     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>     {};
     struct __do_is_destructible_impl   ;
     struct __do_is_nt_destructible_impl   {};
     template<typename _Tp>     struct __is_nt_destructible_impl     : public __do_is_nt_destructible_impl     {};
     template<typename _Tp,            bool = __or_<is_void<_Tp>,                         __is_array_unknown_bounds<_Tp>,                         is_function<_Tp>>::value,            bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>     struct __is_nt_destructible_safe;
     template<typename _Tp>     struct __is_nt_destructible_safe<_Tp, false, false>     : public __is_nt_destructible_impl<typename                remove_all_extents<_Tp>::type>::type     {};
     template<typename _Tp, typename... _Args>     struct __is_constructible_impl     : public __bool_constant<__is_constructible(_Tp, _Args...)>     {};
     template<typename _Tp, typename... _Args>     struct is_constructible       : public __is_constructible_impl<_Tp, _Args...>     {
         static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{}
  ),  "template argument must be a complete class or an unbounded array");
       };
     template<typename _Tp>     struct is_default_constructible     : public __is_constructible_impl<_Tp>::type     {};
     template<typename _Tp, bool = __is_referenceable<_Tp>::value>     struct __is_move_constructible_impl;
     template<typename _Tp>     struct __is_move_constructible_impl<_Tp, false>     : public false_type {};
     template<typename _Tp>     struct is_move_constructible     : public __is_move_constructible_impl<_Tp>     {};
     template<bool, typename _Tp, typename... _Args>     struct __is_nt_constructible_impl     : public false_type     {
   };
     template<typename _Tp, typename... _Args>     using __is_nothrow_constructible_impl       = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),        _Tp, _Args...>;
     template<typename _Tp, typename... _Args>     struct is_nothrow_constructible     : public __is_nothrow_constructible_impl<_Tp, _Args...>::type     {
         static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{}
  ),  "template argument must be a complete class or an unbounded array");
       };
     template<typename _Tp, bool = __is_referenceable<_Tp>::value>     struct __is_nothrow_copy_constructible_impl;
     template<typename _Tp>     struct is_nothrow_copy_constructible     : public __is_nothrow_copy_constructible_impl<_Tp>::type     {};
     template<typename _Tp, bool = __is_referenceable<_Tp>::value>     struct __is_nothrow_move_constructible_impl;
     template<typename _Tp>     struct is_nothrow_move_constructible     : public __is_nothrow_move_constructible_impl<_Tp>::type     {};
     template<typename _Tp, bool = __is_referenceable<_Tp>::value>     struct __is_move_assignable_impl;
     template<typename _Tp>     struct is_move_assignable     : public __is_move_assignable_impl<_Tp>::type     {
         static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{}
  ),  "template argument must be a complete class or an unbounded array");
       };
     template<typename _Tp, typename _Up>     struct __is_nt_assignable_impl     : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>)>     {};
     template<typename _Tp, bool = __is_referenceable<_Tp>::value>     struct __is_nt_move_assignable_impl;
     template<typename _Tp>     struct is_nothrow_move_assignable     : public __is_nt_move_assignable_impl<_Tp>     {
         static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{}
  ),  "template argument must be a complete class or an unbounded array");
       };
     template<typename _Tp, typename _Up>     struct is_trivially_assignable     : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>     {
         static_assert(__is_complete_or_unbounded(__type_identity<_Tp>{}
  ),  "template argument must be a complete class or an unbounded array");
       };
     template<typename _Tp, typename _Up>     struct is_same     : public integral_constant<bool, __is_same_as(_Tp, _Up)>     {};
     template<typename _Tp>     struct remove_volatile     ;
     template<typename _Tp>     struct remove_volatile<_Tp volatile>     ;;
     template<typename _Tp>     struct remove_cv     ;;
     template<typename _Tp>     struct add_volatile     ;;
     template<typename _Tp>     struct remove_reference     ;
     template<typename _Tp,     bool _IsInt = is_integral<_Tp>::value,     bool _IsEnum = is_enum<_Tp>::value>     class __make_unsigned_selector;
     class __make_unsigned_selector_base   ;
     template<typename _Up,     bool _IsArray = is_array<_Up>::value,     bool _IsFunction = is_function<_Up>::value>     struct __decay_selector;
     template<typename _Tp>     class decay     ;;
     template<typename _Tp>     using __decay_t = typename decay<_Tp>::type;
     template<typename _Tp>     class reference_wrapper;
     template<typename _Tp>     struct __strip_reference_wrapper     ;;
     template<typename _Tp>     struct __strip_reference_wrapper     ;
     template<bool, typename _Tp = void>     struct enable_if     ;
     template<typename _Tp>     struct enable_if<true, _Tp>     ;
     template<bool _Cond, typename _Tp = void>     using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
     template<typename... _Cond>     using _Require = __enable_if_t<__and_<_Cond...>::value>;
     template<bool _Cond, typename _Iftrue, typename _Iffalse>     struct conditional     
   ;
     template<typename _Tp>     using __remove_cvref_t      = typename remove_cv<typename remove_reference<_Tp>::type>::type;
     template<typename... _Tp>     struct common_type;
     struct __do_common_type_impl   ;
     template<typename _Tp1, typename _Tp2,     typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>     struct __common_type_impl     ;;
     template<typename, typename, typename = void>     struct __common_type_fold;
     template<typename _Tp, bool = is_enum<_Tp>::value>     struct __underlying_type_impl     ;;
     template<typename _MemPtr, typename _Arg>     struct __result_of_memobj;
     template<typename _Res, typename _Class, typename _Arg>     struct __result_of_memobj<_Res _Class::*, _Arg>     ;
     template<typename _MemPtr, typename _Arg, typename... _Args>     struct __result_of_memfun;
     template<typename _Res, typename _Class, typename _Arg, typename... _Args>     struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>     ;;
     template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>     struct __inv_unwrap     ;
     template<bool, bool, typename _Functor, typename... _ArgTypes>     struct __result_of_impl     ;
     template<typename _Default, typename _AlwaysVoid,     template<typename...> class _Op, typename... _Args>     struct __detector     ;
     template<typename _Default, template<typename...> class _Op,     typename... _Args>     using __detected_or = __detector<_Default, void, _Op, _Args...>;
     template<typename _Default, template<typename...> class _Op,     typename... _Args>     using __detected_or_t       = typename __detected_or<_Default, _Op, _Args...>::type;
   
    
    namespace boost {
   struct use_default ;
   }
    namespace mpl_ {
   
  
   }
    namespace boost {
   namespace mpl {
   using namespace mpl_;
   namespace aux {}
   }
   }
    namespace mpl_ {
   template< bool C_ > struct bool_;
   typedef bool_<true> true_;
   typedef bool_<false> false_;
   }
    namespace mpl_ {
   template< bool C_ > struct bool_ {
   };
   struct na ;
   }
    namespace boost {}
    namespace boost {
   namespace mpl {
   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 T1 = na     , typename T2 = na     , typename T3 = na     > struct if_ {
    private:     typedef if_c<           static_cast<bool>(T1::value)         , T2         , T3         > almost_type_;
    public:     typedef typename almost_type_::type type;
   };
   namespace aux {}
   }
   namespace mpl {
   template<       typename C = na     , typename F1 = na     , typename F2 = na     > struct eval_if {};
   namespace aux {}
   }
  }
    namespace boost {
   namespace mpl {
   template<       typename T = na     > struct identity ;
   template<       typename T = na     > struct make_identity ;
   namespace aux {}
   }
  }
    namespace mpl_ {
   template< int N > struct arg;
   }
    namespace boost {
   namespace mpl {
   namespace aux {
   template< typename T > struct nested_type_wknd     : T::type {};
   }
   };
   template< typename P > struct assert_arg_pred ;
   template< typename P > struct assert_arg_pred_not ;
   }
    namespace mpl_ {
   typedef arg<1> _1;
   }
    namespace boost {
      namespace mpl    {}
      template <class T, T val>    struct integral_constant    {
         static const bool value = val;
      };
      typedef integral_constant<bool, false> false_type;
   template <class T> struct is_void : public false_type {
  };
      template <class T> struct is_lvalue_reference : public false_type{
  };
   template <class T> struct is_rvalue_reference : public false_type {
  };
   template <class T> struct is_reference    : public    integral_constant<       bool,       ::boost::is_lvalue_reference<T>::value || ::boost::is_rvalue_reference<T>::value> {
  };
   namespace type_traits_detail {
       template <typename T, bool b>     struct add_rvalue_reference_helper     ;
       template <typename T>     struct add_rvalue_reference_helper<T, true>     {
           typedef T&& type;
       };
       template <typename T>     struct add_rvalue_reference_imp     {};
   }
   template <class T> struct add_rvalue_reference {
      typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
   };
   }
    namespace boost {
       template <typename T>     typename add_rvalue_reference<T>::type declval()                                                      noexcept                                                                   ;
   namespace detail{
   template <class T> struct remove_rvalue_ref {
      typedef T type;
   };
   template <class T> struct remove_rvalue_ref<T&&> ;
   }
   template <class T> struct remove_reference{
   typedef typename boost::detail::remove_rvalue_ref<T>::type type;
   };
   template <class T> struct remove_reference;
      template <class T>    struct is_function : public false_type {
  };
   }
    namespace boost {
      namespace detail{}
      template <class T> struct is_complete       : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || 0> {};
   template <class T> struct is_integral : public false_type {};
      template <class T> struct is_floating_point : public false_type{};
   template <class T> struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};
   }
    namespace boost {
   namespace detail {
   template <typename T> struct add_reference_impl {
       typedef T& type;
   };
   template <typename T> struct add_reference_impl<T&&> ;
   }
   template <class T> struct add_reference {
      typedef typename boost::detail::add_reference_impl<T>::type type;
   };
   template <class T> struct add_lvalue_reference ;
   namespace detail {
      template <class A, class B, class C>    struct or_helper    
      ;
   template <typename From, typename To> struct is_convertible_impl ;;
   template <typename From, typename To> struct is_convertible_impl_dispatch_base ;;
   template <typename From, typename To> struct is_convertible_impl_dispatch    : public is_convertible_impl_dispatch_base<From, To>::type {
  };
   }
   template <class From, class To> struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value> {};
   }
    
     struct input_iterator_tag {
   };
     struct output_iterator_tag ;
     struct forward_iterator_tag : public input_iterator_tag {};
     struct bidirectional_iterator_tag : public forward_iterator_tag {};
     struct random_access_iterator_tag : public bidirectional_iterator_tag {
   };
     template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,            typename _Pointer = _Tp*, typename _Reference = _Tp&>     struct iterator     ;;
     template<typename _Iterator, typename = __void_t<>>     struct __iterator_traits ;
     template<typename _Iterator>     struct iterator_traits     : public __iterator_traits<_Iterator> {
   };
     template<typename _Tp>     struct iterator_traits     ;
   
    extern "C++" {}
    
     template<typename _Tp>     struct __get_first_arg     ;;
     template<typename _Tp, typename _Up>     struct __replace_first_arg     ;
     template<typename _Ptr>     struct pointer_traits     ;
     template<typename _Iterator>     class reverse_iterator     : public iterator<typename iterator_traits<_Iterator>::iterator_category,         typename iterator_traits<_Iterator>::value_type,         typename iterator_traits<_Iterator>::difference_type,         typename iterator_traits<_Iterator>::pointer,                       typename iterator_traits<_Iterator>::reference>     {
       };
   
    namespace __gnu_cxx __attribute__ (()) {
     template<typename _Iterator, typename _Container>     class __normal_iterator     ;
   }
    
     template<typename _InternT, typename _ExternT, typename _StateT>     class codecvt;
   
   
   
    extern "C" 
    typedef pthread_mutex_t __gthread_mutex_t;
    typedef pthread_mutex_t __gthread_recursive_mutex_t;
    
     template<typename _U1, typename _U2> class __pair_base   {
          };
     template<typename _T1, typename _T2>     struct pair     : private __pair_base<_T1, _T2>     {
         typedef _T1 first_type;
       };
   
    namespace __gnu_cxx __attribute__ (()) {
     template<typename _CharT>     struct char_traits     ;
                     }
    
     template<class _CharT>     struct char_traits : public __gnu_cxx::char_traits<_CharT>     {};
     template<>     struct char_traits<char>     ;
   
    namespace __gnu_cxx __attribute__ (()) {
     template<typename _Tp>     class new_allocator     {
       private:            };
   }
    
     template<typename _Tp>     using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
     template<>     class allocator<void>     {
         template<typename _Tp1>  struct rebind  ;
       };
     template<typename _Tp>     class allocator : public __allocator_base<_Tp>     {
       public:       typedef _Tp value_type;
         typedef size_t size_type;
       };
     struct __allocator_traits_base   {
       template<typename _Tp, typename _Up, typename = void>       struct __rebind : __replace_first_arg<_Tp, _Up> {
   };
     protected:     template<typename _Tp>       using __pointer = typename _Tp::pointer;
     };
     template<typename _Alloc, typename _Up>     using __alloc_rebind       = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
     template<typename _Alloc>     struct allocator_traits : __allocator_traits_base     {};
     template<typename _Tp>     struct allocator_traits<allocator<_Tp>>     {
         using allocator_type = allocator<_Tp>;
         using value_type = _Tp;
         using pointer = _Tp*;
         using const_pointer = const _Tp*;
         using const_void_pointer = const void*;
         using size_type = size_t;
         template<typename _Up>  using rebind_alloc = allocator<_Up>;
   };
     template<typename _Alloc, typename = void>     struct __is_allocator : false_type {};
     template<typename _Alloc>     struct __is_allocator<_Alloc,       __void_t<typename _Alloc::value_type,         decltype(0)>>     : true_type {
   };
   
    namespace __gnu_cxx __attribute__ (()) {
   template<typename _Alloc, typename = typename _Alloc::value_type>   struct __alloc_traits   : allocator_traits<_Alloc>   {
       typedef allocator_traits<_Alloc> _Base_type;
       typedef typename _Base_type::value_type value_type;
       typedef value_type& reference;
       template<typename _Tp>       struct rebind       {
   typedef typename _Base_type::template rebind_alloc<_Tp> other;
   };
     };
   }
    
     template<typename _Result, typename _Arg>     struct __hash_base     ;;
     class logic_error : public exception   {};
     class out_of_range : public logic_error   {
     public:                                      };
   
    namespace boost {
   
   struct no_traversal_tag {
  };
   struct incrementable_traversal_tag   : no_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 Trans_NS_iterators_detail {
     template <class Cat>   struct old_category_to_traversal     : mpl::eval_if<           is_convertible<Cat,random_access_iterator_tag>         , mpl::identity<random_access_traversal_tag>         , mpl::eval_if<               is_convertible<Cat,bidirectional_iterator_tag>             , mpl::identity<>             , mpl::eval_if<                   is_convertible<Cat,forward_iterator_tag>                 , mpl::identity<forward_traversal_tag>                 , mpl::eval_if<                       is_convertible<Cat,input_iterator_tag>                     , mpl::identity<>                     , mpl::eval_if<>                   >               >           >       >   {};
   }
   template <class Cat> struct iterator_category_to_traversal   : mpl::eval_if<> {};
   template <class Iterator = mpl::_1> struct iterator_traversal   : iterator_category_to_traversal<         typename 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 = na     , typename T2 = na     , 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_< na , na > ;
   }
   
     template <typename A, typename B>   struct Trans_NS_iterators_is_interoperable     : mpl::or_<           is_convertible< A, B >         , is_convertible< B, A > >   {};
   
   
   }
    namespace boost {
   
   template <class Iterator> struct iterator_value ;
   template <class Iterator> struct iterator_reference 
   ;
   template <class Iterator> struct iterator_difference ;
   
   namespace mpl {}
  }
    namespace boost {
      template <class T, class U> struct is_same : public false_type {};
   template <class T> struct is_pointer : public false_type{
  };
   namespace detail {
   template <typename T> struct is_class_impl {
      static const     bool value = __is_class(T);
   };
   }
   template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
   }
    namespace boost {}
    namespace boost {
   template <class T> struct remove_cv{
   typedef T type;
   };
   }
    namespace boost {
      template <class T> struct add_const    ;;
   template <typename T> struct add_pointer ;
   template <class T> struct is_enum : public integral_constant<bool, __is_enum(T)> {
  };
   namespace mpl {}
   
   
     namespace Trans_NS_iterators_detail   {}
     namespace Trans_NS_iterators_detail   {
       template <class T, class DefaultNullaryFn>     struct ia_dflt_help       : mpl::eval_if<>     {
      };
       template <         class Derived       , class Base       , class Value       , class Traversal       , class Reference       , class Difference     >     struct iterator_adaptor_base     ;;
            ;
     }
     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 boost::Trans_NS_iterators_detail::iterator_adaptor_base<         Derived, Base, Value, Traversal, Reference, Difference       >::type   {};
   
   }
    namespace boost {}
    
     typedef enum memory_order     {}
   memory_order;
       typedef bool __atomic_flag_data_type;
     extern "C" {
     struct __atomic_flag_base   ;
     };
     template<typename _ITp>     struct __atomic_base     ;;
     template<typename _Tp, typename _Alloc>     struct _Vector_base     {
         typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template  rebind<_Tp>::other _Tp_alloc_type;
         typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer         pointer;
         struct _Vector_impl_data       ;
       };
     template<typename _Tp, typename _Alloc = allocator<_Tp> >     class vector : protected _Vector_base<_Tp, _Alloc>     {};
     enum float_round_style   {
                 round_to_nearest = 1,          round_toward_neg_infinity    };
     enum float_denorm_style   {
       denorm_indeterminate = -1,     denorm_absent ,        };
     struct __numeric_limits_base   {};
     template<typename _Tp>     struct numeric_limits : public __numeric_limits_base     {};
   
    namespace boost {
   
   namespace util {
   
      template <typename T> struct get_unsigned     {
          typedef T result;
      };
      template  struct get_unsigned<int>     ;
      template  struct get_unsigned<long int>     ;;
  
   
   template <typename E, class A = allocator<E> > class SimpleStringStorage ;
   template <typename E, class A = allocator<E> > class AllocatorStringStorage : public A {
       public:     typedef E value_type;
      typedef E* iterator;
      typedef const E* const_iterator;
      typedef A allocator_type;
                      };
   template <     typename Storage,     typename Align =                      typename                                             Storage::value_type* > class CowString {
      typedef typename Storage::value_type E;
      typedef typename get_unsigned<E>::result RefCountType;
  public:     typedef E value_type;
      typedef typename Storage::iterator iterator;
      typedef typename Storage::const_iterator const_iterator;
      typedef typename Storage::allocator_type allocator_type;
      typedef typename allocator_traits<allocator_type>::size_type size_type;
      typedef typename Storage::value_type& reference;
  private:     union     {};
                           };
   template <typename E,     class T = char_traits<E>,     class A = allocator<E>,     class Storage = AllocatorStringStorage<E, A> > class flex_string : private Storage {};
   }
   
   }
    
     
       struct _List_node_base     ;
                     ;
     template<typename _Tp>     struct _List_iterator     ;;
   
     template<typename _Tp, typename _Alloc>     class Trans_NS___cxx11__List_base     {};
     template<typename _Tp, typename _Alloc = allocator<_Tp> >     class Trans_NS___cxx11_list : protected Trans_NS___cxx11__List_base<_Tp, _Alloc>     {
                                          };
   
   
    namespace boost {
   
   
       struct nil_t {
 };
   
   
   
   
   namespace util {
   template <typename StringT> struct file_position ;;
   typedef file_position<boost::util::flex_string< char, char_traits<char>, allocator<char>, boost::util::CowString< boost::util::AllocatorStringStorage<char> > > > file_position_type;
   }
  
   
   enum token_category {
       IdentifierTokenType ,     ParameterTokenType = 0x08840000,     ExtParameterTokenType ,     KeywordTokenType = 0x10040000,     OperatorTokenType = 0x18040000,     LiteralTokenType = 0x20040000,     IntegerLiteralTokenType = 0x20840000,     FloatingLiteralTokenType = 0x21040000,     StringLiteralTokenType ,     CharacterLiteralTokenType = 0x22040000,     BoolLiteralTokenType = 0x22840000,     PPTokenType = 0x28040000,     PPConditionalTokenType = 0x28440000,     UnknownTokenType = 0x50000000,     EOLTokenType ,     EOFTokenType = 0x60000000,     WhiteSpaceTokenType ,     InternalTokenType = 0x70040000,     TokenTypeMask = 0x7F800000,     AltTokenType ,     TriGraphTokenType ,     AltExtTokenType = 0x00280000,     PPTokenFlag = 0x00040000,     ExtTokenTypeMask ,     ExtTokenOnlyMask ,     TokenValueMask = 0x0007FFFF,      };
   enum token_id {
            T_FIRST_TOKEN = 256,          T_AND_ALT = ((T_FIRST_TOKEN) | (OperatorTokenType|AltExtTokenType)),               T_ASSIGN = 0,     T_ANDASSIGN ,     T_ANDASSIGN_ALT ,     T_OR = ((260) | (OperatorTokenType)),     T_OR_ALT = 0,     T_OR_TRIGRAPH = (0 | 0),     T_ORASSIGN = 0,     T_ORASSIGN_ALT = 0,                    T_XOR_TRIGRAPH = 0,     T_XORASSIGN ,     T_XORASSIGN_ALT ,     T_XORASSIGN_TRIGRAPH = 0,     T_COMMA ,     T_COLON ,     T_DIVIDE ,          T_DOT ,     T_DOTSTAR ,     T_ELLIPSIS ,          T_GREATER = ((272) | (OperatorTokenType)),     T_GREATEREQUAL ,     T_LEFTBRACE ,     T_LEFTBRACE_ALT = ((274) | 0),          T_LESS = ((275) | 0),     T_LESSEQUAL ,     T_LEFTPAREN = ((277) | (OperatorTokenType)),     T_LEFTBRACKET = ((278) | (OperatorTokenType)),               T_MINUS = ((279) | 0),     T_MINUSASSIGN = (0 | 0),          T_PERCENT ,          T_NOT ,     T_NOT_ALT ,          T_NOTEQUAL_ALT ,     T_OROR = 0,                              T_ARROW = ((290) | (OperatorTokenType)),          T_QUESTION_MARK ,          T_RIGHTBRACE_ALT = (0 | 0),     T_RIGHTBRACE_TRIGRAPH = (0 | 0),     T_RIGHTPAREN ,               T_RIGHTBRACKET_TRIGRAPH ,     T_COLON_COLON = 0,     T_SEMICOLON = ((297) | (OperatorTokenType)),     T_SHIFTLEFT = 0,     T_SHIFTLEFTASSIGN = (0 | 0),                              T_COMPL_TRIGRAPH = 0,     T_STARASSIGN ,     T_ASM ,          T_BOOL ,               T_BREAK ,                         T_CONST = 0,               T_DEFAULT = ((318) | (KeywordTokenType)),                                   T_EXPLICIT = ((325) | 0),     T_EXPORT = (0 | (KeywordTokenType)),     T_EXTERN ,     T_FLOAT = 0,                    T_IF ,     T_INLINE ,     T_INT ,                         T_OPERATOR ,     T_PRIVATE ,     T_PROTECTED = (0 | 0),                    T_RETURN ,     T_SHORT ,     T_SIGNED = 0,     T_SIZEOF = 0,     T_STATIC = 0,          T_STRUCT = (0 | 0),                         T_TRY ,     T_TYPEDEF = ((357) | (KeywordTokenType)),     T_TYPEID ,     T_TYPENAME = (0 | (KeywordTokenType)),          T_UNSIGNED = ((361) | (KeywordTokenType)),     T_USING = 0,          T_VOID = (0 | (KeywordTokenType)),     T_VOLATILE ,               T_PP_DEFINE = ((368) | (PPTokenType)),                                   T_PP_ERROR ,          T_PP_PRAGMA = 0,     T_PP_UNDEF = (0 | 0),     T_PP_WARNING = 0,     T_IDENTIFIER ,     T_OCTALINT ,     T_DECIMALINT = 0,          T_INTLIT = ((384) | (IntegerLiteralTokenType)),          T_FLOATLIT ,     T_FIXEDPOINTLIT ,          T_CPPCOMMENT ,     T_CHARLIT ,     T_STRINGLIT = (0 | (StringLiteralTokenType)),     T_CONTLINE ,     T_SPACE = 0,          T_NEWLINE ,     T_GENERATEDNEWLINE ,     T_POUND_POUND ,          T_POUND_POUND_TRIGRAPH = 0,     T_POUND ,     T_POUND_ALT = (0 | 0),          T_ANY = 0,                         T_PP_INCLUDE_NEXT = 0,     T_PP_QHEADER_NEXT ,          T_EOF = (0 | (EOFTokenType)),               T_MSEXT_INT8 = (0 | (KeywordTokenType)),     T_MSEXT_INT16 ,     T_MSEXT_INT32 = 0,     T_MSEXT_INT64 = (0 | (KeywordTokenType)),     T_MSEXT_BASED = 0,          T_MSEXT_CDECL ,     T_MSEXT_FASTCALL ,     T_MSEXT_STDCALL ,               T_MSEXT_FINALLY = 0,     T_MSEXT_LEAVE = 0,     T_MSEXT_INLINE = 0,          T_MSEXT_PP_REGION = (0 | 0),               T_ALIGNAS ,          T_CHAR16_T ,     T_CHAR32_T = 0,               T_NOEXCEPT ,     T_NULLPTR = 0,          T_THREADLOCAL ,     T_RAWSTRINGLIT = ((432) | (StringLiteralTokenType)),     T_LAST_TOKEN_ID,     T_LAST_TOKEN = (0 & ~TokenTypeMask),     T_UNKNOWN_UNIVERSALCHAR = (('\\') | (UnknownTokenType)),     T_NONREPLACABLE_IDENTIFIER = ((T_LAST_TOKEN+1) | (IdentifierTokenType)),     T_PLACEHOLDER ,     T_PLACEMARKER ,     T_PARAMETERBASE ,     T_EXTPARAMETERBASE = 0 };
     
                              }
    
     class __mutex_base   {
     protected:     typedef __gthread_mutex_t __native_type;
                    };
     class mutex : private __mutex_base   {};
   
    namespace boost{
   namespace details{
   
   typedef mutex default_mutex;
   
  }
   struct default_user_allocator_new_delete;
   template <typename T,     typename UserAllocator = default_user_allocator_new_delete,     typename Mutex = details::default_mutex,     unsigned NextSize = 32,     unsigned MaxSize = 0> class fast_pool_allocator;
   namespace detail {};
   namespace details {}
      namespace detail{
         union max_align       ;;
   }
   template <size_t Align> struct type_with_alignment ;
   template <bool b, class T, class U> struct conditional ;
   namespace detail {
   
   template <       size_t size_     , size_t alignment_ > struct aligned_storage_imp ;;
   
  }
   namespace detail {}
   
   namespace cpplexer {
   namespace impl {}
   template <typename PositionT = boost::util::file_position_type> class lex_token;
   template <typename PositionT> class lex_token {
  public:     typedef boost::util::flex_string< char, char_traits<char>, allocator<char>, boost::util::CowString< boost::util::AllocatorStringStorage<char> > > string_type;
      typedef PositionT position_type;
  };
   }
   
   }
    namespace boost {
     template<typename T, typename R=void>   struct enable_if_has_type   ;
   
   
       struct default_checking_policy     {};
   
  
   
   namespace iterator_policies {
       struct ref_counted     {
          struct unique         {};
          struct shared         ;
      };
   }
  
  }
    namespace boost {
   namespace detail {
   template <typename T> struct empty_helper_t1 : public T {
            int i[256];
   private:         };
   struct empty_helper_t2 {
   int i[256];
   };
   template <typename T, bool is_a_class = false> struct empty_helper ;;
   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::detail::empty_helper<cvt,::boost::is_class<T>::value>::value || false)                                                                                                                          ;
   };
   }
   template <class T> struct is_empty : integral_constant<bool, ::boost::detail::is_empty_impl<T>::value> {
  };
   }
    namespace boost {
   
   namespace iterator_policies {
       struct split_functor_input     {
          template <typename Functor           , bool FunctorIsEmpty = is_empty<typename Functor::first_type>::value>         class unique;
          template <typename Functor>         class unique<Functor, true>         {
          protected:             typedef typename Functor::first_type functor_type;
              typedef typename functor_type::result_type result_type;
          public:             typedef result_type value_type;
                      };
      };
   }
  
   
   namespace iterator_policies {
       struct no_check     {
          struct unique : public default_checking_policy {};
          struct shared ;
      };
       struct split_std_deque     {
          enum {};
          template <typename Value>         class unique         {};
      };
   }
  
   
   namespace iterator_policies {
       template <typename T       , typename Ownership, typename Checking, typename Input, typename Storage       , bool OwnershipIsEmpty = boost::is_empty<Ownership>::value       , bool CheckingIsEmpty = boost::is_empty<Checking>::value       , bool InputIsEmpty = boost::is_empty<Input>::value>     struct multi_pass_unique;
       template <typename T, typename Ownership, typename Checking       , typename Input, typename Storage>     struct multi_pass_unique<T, Ownership, Checking, Input, Storage           , true, true, true>       : Storage     {};
       template<typename T, typename Ownership, typename Checking, typename Input       , typename Storage>     struct multi_pass_shared : Ownership, Checking, Input, Storage     {
                        };
       template<typename Ownership, typename Checking, typename Input       , typename Storage>     struct default_policy     {
          typedef Checking checking_policy;
          typedef Input input_policy;
          typedef Storage storage_policy;
          template <typename T>         struct unique : multi_pass_unique<T           , typename Ownership::unique, typename Checking::unique           , typename Input::                            template                                                   unique<T>           , typename Storage::                              template                                                     unique<                 typename Input::                                template                                                       unique<T>::value_type> >         {
              typedef typename Ownership::unique ownership_policy;
              typedef typename Input::                                    template                                                           unique<T>                 input_policy;
                                                 };
          template <typename T>         struct shared : multi_pass_shared<T           , typename Ownership::shared, typename Checking::shared           , typename Input::                            template                                                   shared<T>           , typename Storage::                              template                                                     shared<                 typename Input::                                template                                                       unique<T>::value_type> >         {};
      };
   }
   
   template < typename MemberType, int UniqueID = 0 > class base_from_member {
   };
   
       template<typename T, typename Policies>     class multi_pass       : private boost::base_from_member<             typename Policies::                               template                                                      shared<T>*>       , public Policies::                         template                                                unique<T>     {
       private:         typedef typename Policies::                                   template                                                          unique<T>             policies_base_type;
           typedef typename policies_base_type::input_policy iterator_type;
       public:         typedef forward_iterator_tag iterator_category;
                                                             private:              };
       namespace traits     {
       }
   
   
   namespace cpplexer {
   template <typename TokenT> struct lex_input_interface ;
   }
   namespace cpplexer {
   namespace impl {
  template <typename TokenT> class lex_iterator_functor_shim {
  public:          typedef TokenT result_type;
      typedef lex_iterator_functor_shim unique;
      typedef lex_input_interface<TokenT>* shared;
  };
  }
   template <typename FunctorData> struct make_multi_pass {
      typedef         pair<typename FunctorData::unique, typename FunctorData::shared>     functor_data_type;
      typedef typename FunctorData::result_type result_type;
      typedef boost::iterator_policies::split_functor_input input_policy;
      typedef boost::iterator_policies::ref_counted ownership_policy;
      typedef boost::iterator_policies::no_check check_policy;
      typedef boost::iterator_policies::split_std_deque storage_policy;
      typedef boost::iterator_policies::default_policy<             ownership_policy, check_policy, input_policy, storage_policy>         policy_type;
      typedef boost::multi_pass<functor_data_type, policy_type> type;
  };
   template <typename TokenT> class lex_iterator : public make_multi_pass<impl::lex_iterator_functor_shim<TokenT> >::type {
      typedef impl::lex_iterator_functor_shim<TokenT> input_policy_type;
      typedef typename make_multi_pass<input_policy_type>::type base_type;
      typedef typename input_policy_type::shared shared_functor_type;
  public:     typedef TokenT token_type;
            };
   }
   
   namespace detail{
   template <typename T, bool isp, bool b1, bool b2> struct ct_imp {
      typedef const T& param_type;
   };
   }
   template <typename T> struct call_traits {
      typedef T& reference;
      typedef const T& const_reference;
      typedef typename boost::detail::ct_imp<       T,       ::boost::is_pointer<T>::value,       ::boost::is_arithmetic<T>::value,       ::boost::is_enum<T>::value    >::param_type param_type;
   };
       template< class T >     struct decay     ;
      template <class T> using decay_t = typename decay<T>::type;
   namespace detail {
   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;
      static const     bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
   };
   }
   template <class Base, class Derived> struct is_base_and_derived    : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {
  };
      namespace detail{
         template <class B, class D>       struct is_base_of_imp       ;
   }
   template<class T> class optional ;
   
   
       
          template <typename T>         struct no_base {
 };
          template <typename T>         struct safe_bool_impl         ;;
      
       template <typename DerivedT, typename BaseT = no_base<DerivedT> >     struct safe_bool : BaseT     {};
   
   
   
   
       template <typename T = nil_t>     class match : public safe_bool<match<T> >     {};
       template <>     class match<> : public safe_bool<match<nil_t> >     {
      public:         typedef nil_t attr_t;
          typedef nil_t return_t;
                                       ;
      };
       class parser_id     {
      public:                                                   
                                          private:         union         {
              void const* p;
          };
      };
       struct parser_tag_base {};
       struct parser_address_tag : parser_tag_base     {
               };
       class dynamic_parser_tag : public parser_tag_base     {
      private:         parser_id tag;
      };
   
   
   
   
       struct iteration_policy;
       struct action_policy;
       struct match_policy;
       template <         typename IterationPolicyT = iteration_policy,         typename MatchPolicyT = match_policy,         typename ActionPolicyT = action_policy>     struct scanner_policies;
       template <         typename IteratorT = char const*,         typename PoliciesT = scanner_policies<> >     class scanner;
   
   
       struct iteration_policy     {};
       struct match_policy     {};
       template <typename MatchPolicyT, typename T>     struct match_result     {
          typedef typename MatchPolicyT::template result<T>::type type;
      };
       struct action_policy     {
      };
       template <         typename IterationPolicyT,         typename MatchPolicyT,         typename ActionPolicyT>     struct scanner_policies :         public IterationPolicyT,         public MatchPolicyT,         public ActionPolicyT     {
          typedef IterationPolicyT iteration_policy_t;
          typedef MatchPolicyT match_policy_t;
          typedef ActionPolicyT action_policy_t;
      };
       struct scanner_base {};
       template <         typename IteratorT,         typename PoliciesT>     class scanner : public PoliciesT, public scanner_base     {
      public:         typedef IteratorT iterator_t;
          typedef PoliciesT policies_t;
          typedef typename boost::             call_traits<IteratorT>::param_type iter_param_t;
          scanner(             IteratorT& first_,             iter_param_t last_,             PoliciesT const& policies = PoliciesT())          ;
      private:              };
   
   
   
   
       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 boost::remove_reference<ParserT>::type parser_type;
          typedef typename parser_type::template result<ScannerT>::type type;
      };
       template <typename DerivedT>     struct parser     {
          typedef DerivedT embed_t;
          typedef plain_parser_category parser_category_t;
          template <typename ScannerT>         struct result         ;
                   DerivedT const& derived() const         ;
          template <typename ActionT>         action<DerivedT, ActionT>         operator[](ActionT const& actor) const         ;
      };
   
   
       template <typename DerivedT>     struct char_parser : public parser<DerivedT>     {};
       template <typename CharT = char>     struct chlit : public char_parser<chlit<CharT> >     {
      };
       template <typename CharT>      chlit<>     ch_p(CharT ch)     ;
       template <typename IteratorT = char const*>     class chseq : public parser<chseq<IteratorT> >     {};
       template <typename IteratorT = char const*>     class strlit : public parser<strlit<IteratorT> >     {
      };
       struct anychar_parser : public char_parser<anychar_parser>     {
      };
       anychar_parser const anychar_p = anychar_parser();
         
   
   template <class T> struct is_final : public integral_constant<bool, __is_final(T)> {};
   namespace details {
      template<class T, bool E = boost::is_final<T>::value>    struct compressed_pair_empty       : ::boost::false_type {
   };
      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, false>       ;;
      template <class T1, class T2, int Version> class compressed_pair_imp;
      template <class T1, class T2>    class compressed_pair_imp<T1, T2, 0>    {
      public:       typedef T1 first_type;
                                                                     private:       first_type first_;
      };
      template <class T1, class T2>    class compressed_pair_imp<T1, T2, 5>    ;
   }
   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::details::compressed_pair_empty<T1>::value,                     ::boost::details::compressed_pair_empty<T2>::value>::value> {
                                                         };
   
   
       template <typename S, typename BaseT>     class unary : public BaseT     {
      public:         typedef BaseT base_t;
          typedef typename S::embed_t subject_embed_t;
                        private:         subject_embed_t subj;
      };
       template <typename A, typename B, typename BaseT>     class binary : public BaseT     {
          typedef typename A::embed_t left_embed_t;
          typedef typename B::embed_t right_embed_t;
                                 private:         boost::compressed_pair<left_embed_t, right_embed_t> subj;
      };
   
       
       struct default_parser_context_base     {
          template <typename DerivedT>         struct aux {
 };
      };
       struct parser_context_base {
 };
       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 > context_linker_t;
      };
       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_)  ;
      };
       template<typename ContextT>     struct parser_context_linker : public ContextT     {
          template <typename ParserT>         parser_context_linker(ParserT const& p)  ;
          template <typename ResultT, typename ParserT, typename ScannerT>         ResultT&         post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan)         ;
      };
       
       
   }
    namespace boost {}
    namespace boost {
   template<class T> class scoped_ptr {};
   
   
       
          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;
          };
          class rule_base_access         ;
          template <             typename DerivedT           , typename EmbedT           , typename T0           , typename T1           , typename T2         >         class rule_base             : public parser<DerivedT>             , public get_context<T0, T1, T2>::type::base_t             , public context_aux<                 typename get_context<T0, T1, T2>::type, DerivedT>             , public get_tag<T0, T1, T2>::type         {
          public:             typedef typename get_scanner<T0, T1, T2>::type scanner_t;
              typedef typename get_context<T0, T1, T2>::type context_t;
              typedef typename get_tag<T0, T1, T2>::type tag_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             ;
              template <typename ScannerT>             typename parser_result<DerivedT, ScannerT>::type             parse(void) const             ;
          };
          template <typename ScannerT, typename AttrT>         struct abstract_parser         ;;
          template <typename ParserT, typename ScannerT, typename AttrT>         struct concrete_parser : abstract_parser<ScannerT, AttrT>         {};
      
   
   
   
   
       template <         typename T0 = nil_t       , typename T1 = nil_t       , typename T2 = nil_t     >     class rule         : public rule_base<             rule<T0, T1, T2>           , rule<> const&           , T0, T1, T2>     {
      public:         typedef rule self_t;
          typedef 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 abstract_parser<scanner_t, attr_t> abstract_parser_t;
          rule()  ;
          template <typename ParserT>         rule& operator=(ParserT const& p)         ;
                                     scoped_ptr<abstract_parser_t> ptr;
      };
   
   
   namespace detail {
   template< class D > struct sp_convert_reference ;
     }
   }
    namespace boost {
   namespace movelib {}
   namespace detail {
   template< class T > struct sp_element {
       typedef T type;
   };
   template< class T > struct sp_member_access {
       typedef T * type;
   };
   }
   template<class T> class shared_ptr {
   public:     typedef typename boost::detail::sp_element< T >::type element_type;
                             ;
            typename boost::detail::sp_member_access< T >::type operator-> () const                                                                             noexcept    ;
   };
   namespace detail {}
            ;
   }
    namespace boost {
   namespace date_time {}
   namespace date_time {
     enum time_resolutions {};
   }
   
   namespace operators_detail {
   template <typename T> class empty_base {
 };
   }
   template <class T, class U, class B = operators_detail::empty_base<T> > struct less_than_comparable2 : B {
                     };
   template <class T, class B = operators_detail::empty_base<T> > struct equality_comparable1 : B {};
   template <class T, class U, class B = operators_detail::empty_base<T> > struct multipliable2 : B {
    };
   template <class T, class U, class B = operators_detail::empty_base<T> > struct dividable2 : B {
  };
   namespace operators_detail {
   struct true_t ;;
   struct false_t ;
   }
   template<class T> struct is_chained_base {
     typedef operators_detail::false_t value;
   };
   template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable;
   template<class T, class U, class B> struct less_than_comparable<T, U, B, operators_detail::false_t> : less_than_comparable2<T, U, B> {
   };
   template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable;
   template<class T, class U> struct equality_comparable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : equality_comparable1<T, U> {
   };
   template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable;
   template<class T, class U, class B> struct multipliable<T, U, B, operators_detail::false_t> : multipliable2<T, U, B> {
      };
   
   
   }
    namespace boost {}
    namespace boost {}
    namespace boost {
   
   
   namespace date_time {}
   }
    namespace boost {
   
     class millisec_posix_time_system_config   ;;
   
   namespace date_time {
     template<class config>   struct counted_time_rep   
     ;
     template<class time_rep>   class counted_time_system   ;
   }
   }
    namespace boost {
   
     typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
     typedef date_time::counted_time_system<int64_time_rep> posix_time_system;
   
   namespace date_time {
     template <class T, class time_system>   class base_time : private       boost::less_than_comparable<T     , boost::equality_comparable<T       > >   {
     };
   }
   
   }
    namespace mpl_ {
   template< typename T, T N > struct integral_c ;
   
   
   template< typename Tag1, typename Tag2 > struct gcd_impl;
   template< typename T > struct gcd_tag ;;
   template<       typename N1 = na     , typename N2 = na     > struct gcd     : gcd_impl<           typename gcd_tag<N1>::type         , typename gcd_tag<N2>::type         >::template apply<>::type {
   };
   
   
   template< typename Tag1, typename Tag2 > struct lcm_impl;
   template< typename T > struct lcm_tag ;
   template<       typename N1 = na     , typename N2 = na     > struct lcm     : lcm_impl<           typename lcm_tag<N1>::type         , typename lcm_tag<N2>::type         >::template apply<N1, N2>::type {};
   template<       typename T     , T n1     , T n2     > struct lcm_c     : lcm<integral_c<T,n1>,integral_c<T,n2> > {
   };
   
  }
    namespace boost {
   template<class T> class integer_traits : public numeric_limits<T> {
   };
   namespace detail {
   template<class T, T min_val, T max_val> class integer_traits_base ;
   };
   template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;
   typedef ratio<1L, 1000000000L> nano;
   namespace ratio_detail {
     template <class R1, class R2>   struct ratio_subtract   ;
   };
   }
    namespace boost {
   namespace type_traits_detail {
   template<template<class...> class F, class... T> struct mp_valid_impl ;;
   template<template<class...> class F, class... T> using mp_valid = typename mp_valid_impl<F, T...>::type;
   struct mp_empty ;
   template<template<class...> class F, class... T> struct mp_defer_impl ;;
   template<template<class...> class F, class... T> using mp_defer = typename boost::conditional<mp_valid<F, T...>::value, mp_defer_impl<F, T...>, mp_empty>::type;
   }
   }
    namespace boost {
   template<class... T> struct common_type ;;
   template<class... T> using common_type_t = typename common_type<T...>::type;
   namespace type_traits_detail {
   template<class T1, class T2, class... T> using common_type_fold = common_type_t<common_type_t<T1, T2>, T...>;
   }
   template<class T1, class T2, class... T> struct common_type<T1, T2, T...>: type_traits_detail::mp_defer<type_traits_detail::common_type_fold, T1, T2, T...> {
   };
   namespace type_traits_detail {
   template<class T1, class T2> using builtin_common_type = typename boost::decay<decltype( boost::declval<bool>? boost::declval<T1>(): 0 )>::type;
   template<class T1, class T2> struct common_type_impl: mp_defer<builtin_common_type, T1, T2> {};
       template <class Rep, class Period>     class __attribute__(()) duration     ;
   namespace detail {
   }
             }
   namespace chrono {
   }
   }
    namespace boost {}
    namespace boost {
     namespace detail   {
     }
       class mutex     {
       };
   
   }
    namespace boost {
   
   
   
   
   
   
   
                          
     struct once_flag   ;
        ;
   
   
       
          template <typename IdT = size_t>         struct object_with_id_base_supply         ;;
          template <typename TagT, typename IdT = size_t>         struct object_with_id_base         {
          };
          template<class TagT, typename IdT = size_t>         struct object_with_id : private object_with_id_base<TagT, IdT>         {
              typedef object_with_id<TagT, IdT> self_t;
              typedef IdT object_id;
              object_id get_object_id() const ;
          };
                                                            
   
   
   namespace move_upmu {
   struct nat{
  };
   template <class T> struct natify;
   template <bool B, class T = nat> struct enable_if_c {
      typedef T type;
   };
   template< class T > struct remove_const ;
   template< class T > struct remove_volatile ;;
   template<class T> struct remove_extent {
      typedef T type;
   };
   template<class T> struct add_lvalue_reference {
      typedef T& type;
   };
   template<class T> struct add_const_lvalue_reference ;
   template<class T> struct is_array {
      static const bool value = false;
   };
   template <class T> struct has_pointer_type {
      struct two {
  char c[2];
  };
      template <class U> static two test(...);
      static const bool value = sizeof(0) == 1;
   };
   template <class T, class D, bool = has_pointer_type<D>::value> struct pointer_type_imp {
       typedef T* type;
   };
   template <class T, class D> struct pointer_type {
       typedef typename pointer_type_imp       <typename remove_extent<T>::type, typename remove_reference<D>::type>::type type;
   };
   template <class T, class U> class is_convertible {
      typedef typename add_lvalue_reference<T>::type t_reference;
      typedef char true_t;
          static true_t dispatch(U);
      static t_reference trigger();
      public:    static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
  };
   }
   namespace move_upd {
   namespace bmupmu = ::boost::move_upmu;
   }
   namespace movelib {
   namespace bmupd = boost::move_upd;
   namespace bmupmu = ::boost::move_upmu;
   template <class T> struct default_delete ;
   }
   namespace move_upd {
   template <class P1, class P2> struct is_same_cvelement_and_convertible ;;
   template<bool IsArray, class FromPointer, class ThisPointer> struct is_unique_ptr_convertible    : is_same_cvelement_and_convertible<FromPointer, ThisPointer> {};
   template<class FromPointer, class ThisPointer> struct is_unique_ptr_convertible<false, FromPointer, ThisPointer>    : bmupmu::is_convertible<FromPointer, ThisPointer> {
  };
   template<class T, class FromPointer, class ThisPointer, class Type = bmupmu::nat> struct enable_up_ptr    : bmupmu::enable_if_c< is_unique_ptr_convertible       < bmupmu::is_array<T>::value, FromPointer, ThisPointer>::value, Type> {
  };
   }
   namespace movelib {
   template <class T, class D = default_delete<T> > class unique_ptr {
   private:    typedef bmupmu::pointer_type<T, D > pointer_type_obtainer;
      public:    typedef typename pointer_type_obtainer::type pointer;
              template<class Pointer>    __attribute__ (())                           explicit unique_ptr(Pointer p       , typename bmupd::enable_up_ptr<T , Pointer , pointer>::type* =0                  )     ;
               };
   }
   }
    namespace boost {
   template<class T> class weak_ptr {
   public:     typedef typename boost::detail::sp_element< T >::type element_type;
       shared_ptr<T> lock() const                                noexcept    ;
            
   };
   }
    namespace boost {
   namespace noncopyable_ {
     struct base_token {
  };
     class noncopyable: base_token   {
     protected:                              };
   }
   typedef noncopyable_::noncopyable noncopyable;
   
   
       template <class T, class Tag>     struct static_         : boost::noncopyable     {
      private:         struct destructor         ;;
          struct default_ctor         {
                       };
      public:         typedef T value_type;
          typedef typename boost::call_traits<T>::reference reference;
          typedef typename boost::call_traits<T>::const_reference const_reference;
          static_(Tag = Tag())         ;
          operator reference()         ;
      };
   
   
       template <typename T>     class thread_specific_ptr     {
       public:         typedef T element_type;
                                      T* get() const         ;
                    typename add_reference<T>::type operator*() const         ;
                    void reset()         ;
       };
   }
    namespace boost {
   
   
   template <typename DerivedT, typename ContextT> struct grammar;
   template <typename GrammarT, typename ScannerT> struct grammar_definition {
      typedef typename GrammarT::template definition<ScannerT> type;
  };
       
      struct grammar_tag ;;
      template <typename GrammarT>     struct grammar_helper_base     {
          
      };
      template <typename GrammarT>     struct grammar_helper_list     {
          typedef grammar_helper_base<GrammarT> helper_t;
                            void push_back()         ;
          
          boost::mutex m;
      };
      struct grammartract_helper_list     {
          template<typename GrammarT>         static grammar_helper_list<GrammarT>&         do_()         ;
      };
      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_() {
  }
          grammar_helper(helper_weak_ptr_t& p)         : definitions_cnt(0)         , self()         {
  }
          definition_t&         define(grammar_t const* target_grammar)         {
              typename grammar_t::object_id id = 0;
              boost::movelib::unique_ptr<definition_t>                 result(new definition_t(target_grammar->derived()));
          }
          int         undefine()         {
              typename grammar_t::object_id id = 0;
          }
      private:         vector<definition_t*> definitions;
          unsigned long definitions_cnt;
          helper_ptr_t self;
      };
      class get_definition_static_data_tag     {};
      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 grammar_helper<self_t, DerivedT, ScannerT> helper_t;
          typedef typename helper_t::helper_weak_ptr_t ptr_t;
          boost::thread_specific_ptr<ptr_t> & tld_helper             = static_<boost::thread_specific_ptr<ptr_t>,                 get_definition_static_data_tag>();
          if (!tld_helper.get())             0;
          ptr_t &helper = *tld_helper;
          return helper.lock()->define(self);
      }
      template <int N>     struct call_helper ;;
      template <>     struct call_helper<0> ;;
      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);
          0;
          return result;
      }
      template<typename GrammarT>     inline void     grammar_destruct(void)     {
    GrammarT * self = 0;}
      template <typename DerivedT, int N, typename ContextT>     class entry_grammar         : public parser<entry_grammar<DerivedT, N, ContextT> >     {
      public:         typedef entry_grammar self_t;
          typedef self_t embed_t;
          typedef typename ContextT::context_linker_t context_t;
          typedef typename context_t::attr_t attr_t;
          template <typename ScannerT>         struct result         ;
                                 private:         DerivedT const &target_grammar;
      };
      
   template <typename DerivedT, typename ContextT = parser_context<> > struct grammar     : public parser<DerivedT>     , public ContextT::base_t     , public context_aux<ContextT, DerivedT>     , public object_with_id<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;
      };
      template <typename ScannerT>     typename parser_result<self_t, ScannerT>::type     parse_main(ScannerT const& scan) const     {
  return 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);
  result_t hit = parse_main(scan);
  return context_wrap.post_parse(hit, *this, scan_wrap);
      }
  mutable grammar_helper_list<self_t> helpers;
  };
   
   
   
  }
    namespace boost {
   
   
       
          template<typename T>         struct default_as_parser         {
              typedef T type;
                       };
          struct char_as_parser         ;;
          struct wchar_as_parser         ;
      
       template<typename T>     struct as_parser : default_as_parser<T> {};
   
   
  }
    namespace boost {
   
   
       template <typename A, typename B>     struct sequence : public binary<A, B, parser<sequence<A, B> > >     {
      };
       template <typename A, typename B>     sequence<A, B>     operator>>(parser<A> const& a, parser<B> const& b);
             
   
  }
    namespace boost {
   
   
   
   
  }
    namespace boost {
   
   
       template <typename A, typename B>     struct alternative     : public binary<A, B, parser<alternative<A, B> > >     {
                            ;
      };
       template <typename A, typename B>     alternative<A, B>     operator|(parser<A> const& a, parser<B> const& b);
   
   
       struct difference_parser_gen;
       template <typename A, typename B>     struct difference     : public binary<A, B, parser<difference<A, B> > >     {};
       template <typename A, typename B>     difference<A, B>     operator-(parser<A> const& a, parser<B> const& b);
   
   
  }
    namespace boost {
   
   
       struct exclusive_or_parser_gen;
       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<S, parser<self_t> > base_t;
          kleene_star(S const& a)         : base_t() {
 }
               };
       struct kleene_star_parser_gen     ;
       template <typename S>     kleene_star<S>     operator*(parser<S> const& a);
   
   
       template <typename S>     struct positive     : public unary<S, parser<positive<S> > >     {
          typedef positive<S> self_t;
          typedef unary<S, parser<self_t> > base_t;
          positive(void)         : base_t() {
    const S & a;
 }
               };
       template <typename S>     inline positive<S>     operator+(parser<S> const& a);
   
   
   
   
       template <typename S>     struct Trans_NS_classic_optional     : public unary<S, parser<Trans_NS_classic_optional<S> > >     {
          typedef Trans_NS_classic_optional<S> self_t;
          typedef unary<S, parser<self_t> > base_t;
                        };
       template <typename S>     Trans_NS_classic_optional<S>     operator!(parser<S> const& a);
   
   
   template <typename T> struct is_parser {
     static const     bool value = (::boost::is_base_and_derived<parser<T>, T>::value)                                                             ;
  };
   
   
   
   
       template <typename CondT, bool positive_ = true>     struct condition_parser : parser<condition_parser<CondT, positive_> >     {
      };
       struct empty_match_parser_gen;
       template<typename SubjectT>     struct empty_match_parser     : unary<SubjectT, parser<empty_match_parser<SubjectT> > >     {
                   template <typename ScannerT>         struct result         ;;
                   ;
               };
       
          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>     {
          template <typename SubjectT>         typename epsilon_selector<SubjectT>::type         operator()() const         ;
      };
       epsilon_parser const eps_p = epsilon_parser();
   
   
       template <typename ValueT = nil_t>     class node_val_data_factory;
       template <         typename IteratorT,         typename NodeFactoryT = node_val_data_factory<>,         typename T = nil_t     >     class tree_match;
       template <         typename IteratorT = char const *,         typename NodeFactoryT = node_val_data_factory<nil_t>,         typename T = nil_t     >     struct tree_parse_info;
   
   
  }
    namespace boost {
   
   
   template <typename T> struct tree_node {
      typedef allocator<tree_node<T> > allocator_type;
      typedef vector<tree_node<T>, allocator_type> children_t;
      children_t children;
                           };
   template <typename IteratorT = char const*, typename ValueT = nil_t> struct node_val_data ;;
   template <typename ValueT> class node_val_data_factory {
  public:     template <typename IteratorT>     class factory     {
      public:         typedef IteratorT iterator_t;
          typedef node_val_data<> node_t;
      };
  };
   template <typename IteratorT, typename NodeFactoryT, typename T> class tree_match : public match<> {};
   template <     typename MatchPolicyT,     typename IteratorT,     typename NodeFactoryT,     typename TreePolicyT,     typename T > struct common_tree_match_policy : public match_policy {
                 ;
      template <typename U>     struct result {
  typedef tree_match<IteratorT, NodeFactoryT, U> type;
  };
      typedef tree_match<IteratorT, NodeFactoryT, T> match_t;
  };
   struct no_tree_gen_node_parser_gen;
   template <typename T> struct no_tree_gen_node_parser : public unary<T, parser<no_tree_gen_node_parser<T> > > {
      typedef unary_parser_category parser_category_t;
  };
   struct no_tree_gen_node_parser_gen {
      template <typename T>     struct result ;
      template <typename T>     no_tree_gen_node_parser<T>     operator[](parser<T> const& s) const     ;
  };
   const no_tree_gen_node_parser_gen no_node_d = no_tree_gen_node_parser_gen();
   template <     typename IteratorT,     typename NodeFactoryT,     typename T > struct tree_parse_info {};
       template <         typename MatchPolicyT,         typename NodeFactoryT,         typename T = nil_t     >     struct pt_tree_policy;
       template <         typename IteratorT,         typename NodeFactoryT = node_val_data_factory<>,         typename T = nil_t     >     struct pt_match_policy;
   
   
   template <     typename IteratorT,     typename NodeFactoryT,     typename T > struct pt_match_policy :     public common_tree_match_policy<         pt_match_policy<IteratorT, NodeFactoryT, T>,         IteratorT,         NodeFactoryT,         pt_tree_policy<             pt_match_policy<IteratorT, NodeFactoryT, T>,             NodeFactoryT,             T         >,         T     > {
      typedef         common_tree_match_policy<             pt_match_policy,             IteratorT,             NodeFactoryT,             pt_tree_policy<                 pt_match_policy,                 NodeFactoryT,                 T             >,             T         >     common_tree_match_policy_;
      pt_match_policy()     ;
  };
   struct non_nested ;
   struct non_lexeme {
 };
   template <     typename OpenT, typename ExprT, typename CloseT, typename CategoryT,     typename NestedT, typename LexemeT > struct confix_parser :     public parser<         confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT>     > {
      typename as_parser<CloseT>::type::embed_t close;
  };
   template<typename NestedT, typename LexemeT> struct confix_parser_gen {
      template<typename StartT, typename ExprT, typename EndT>     struct paren_op_result_type     {
          typedef 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         > type;
      };
      template<typename StartT, typename ExprT, typename EndT>     typename paren_op_result_type<StartT, ExprT, EndT>::type     operator()(StartT const &start_, ExprT const &expr_, EndT const &end_) const     ;
      template<typename StartT, typename ExprT, typename EndT>     struct direct_result_type     ;
  };
   const confix_parser_gen<non_nested, non_lexeme> confix_p =     confix_parser_gen<non_nested, non_lexeme>();
   
   
   
   
       struct no_list_endtoken;
       template <         typename ItemT, typename DelimT, typename EndT = no_list_endtoken,         typename CategoryT = plain_parser_category     >     struct list_parser;
   
   
   
   
   template <     typename ItemT, typename DelimT, typename EndT, typename CategoryT > struct list_parser :     public parser<list_parser<ItemT, DelimT, EndT, CategoryT> > {
                ;
      typename as_parser<DelimT>::type::embed_t delim;
  };
   template <typename CharT = char> struct list_parser_gen :     public list_parser<kleene_star<anychar_parser>, chlit<CharT> > {
      typedef list_parser_gen self_t;
      list_parser_gen()      ;
      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     ;
  };
   const list_parser_gen<> list_p = list_parser_gen<>();
       ;
   ;
   template <typename T,     typename UserAllocator,     typename Mutex,     unsigned NextSize,     unsigned MaxSize > class fast_pool_allocator ;
   
   
   template <typename LexIteratorT, typename TokenContainerT> struct __attribute__((__visibility__("default"))) cpp_grammar_gen {
      typedef LexIteratorT iterator_type;
      typedef typename LexIteratorT::token_type token_type;
      typedef TokenContainerT token_container_type;
      typedef typename token_type::position_type position_type;
      typedef boost::node_val_data_factory<         > node_factory_type;
      static boost::tree_parse_info<iterator_type, node_factory_type>     parse_cpp_grammar (iterator_type const &first, iterator_type const &last,         position_type const &act_pos, bool &found_eof,         token_type &found_directive, token_container_type &found_eoltokens);
  };
       template <typename CharT = char>     struct pattern_and       : public boost::char_parser<pattern_and<CharT> >     {
          unsigned long pattern_mask;
      };
       template <typename CharT>      pattern_and<CharT>     pattern_p(CharT pattern, unsigned long pattern_mask = 0UL)     ;
   
   
   
      struct store_found_eof ;
      template <typename TokenT>     struct store_found_directive {
          store_found_directive(void)  ;
      };
      template <typename ContainerT>     struct store_found_eoltokens ;;
      struct flush_underlying_parser     : public boost::parser<flush_underlying_parser>     {
               };
  
   template <typename TokenT, typename ContainerT> struct cpp_grammar :     public boost::grammar<cpp_grammar<TokenT, ContainerT> > {
      typedef store_found_directive<TokenT> store_found_directive_type;
      template <typename ScannerT>     struct definition     {
          typedef typename ScannerT::iteration_policy_t iteration_policy_t;
          typedef boost::match_policy match_policy_t;
          typedef typename ScannerT::action_policy_t action_policy_t;
          typedef             boost::scanner_policies<>             policies_t;
          typedef             boost::scanner<typename ScannerT::iterator_t, policies_t>             non_tree_scanner_t;
          typedef             boost::rule<                 non_tree_scanner_t, boost::dynamic_parser_tag>             no_tree_rule_type;
          typedef             boost::rule<>             rule_type;
          rule_type pp_statement, macro_include_file;
          rule_type plain_define, macro_definition, macro_parameters;
          rule_type ppqualifiedname;
          no_tree_rule_type ppsp;
          pattern_and<> __trans_tmp_1;
definition(cpp_grammar const &self)         {
              using namespace boost;
              using namespace boost::util;
              boost::chlit<char> __trans_tmp_1 = ch_p(T_PP_DEFINE);
              boost::alternative<boost::chlit<char>, boost::chlit<char> > __trans_tmp_2 = ch_p(T_IDENTIFIER)                         | __trans_tmp_1;
              plain_define                 = no_node_d                     [                         __trans_tmp_1                                                  >> +ppsp                     ]                     >> ( __trans_tmp_2                         | pattern_p(OperatorTokenType|AltExtTokenType,                                 ExtTokenTypeMask|PPTokenFlag)                         | pattern_p(BoolLiteralTokenType,                                 TokenTypeMask|PPTokenFlag)                         )                     >> ( ( no_node_d[eps_p]                                 >> macro_parameters                                 >> !macro_definition                             )                         | !( no_node_d[+ppsp]                                 >> macro_definition                             )                         )                 ;
              macro_parameters                 = confix_p(                         no_node_d[ch_p(T_LEFTPAREN) >> *ppsp],                        !list_p(                             ( ch_p(T_IDENTIFIER)                             | pattern_p(KeywordTokenType,                                     TokenTypeMask|PPTokenFlag)                             | pattern_p(OperatorTokenType|AltExtTokenType,                                     ExtTokenTypeMask|PPTokenFlag)                             | pattern_p(BoolLiteralTokenType,                                     TokenTypeMask|PPTokenFlag)                             | ch_p(T_ELLIPSIS)                             ),                             no_node_d[*ppsp >> ch_p(T_COMMA) >> *ppsp]                         ),                         no_node_d[*ppsp >> ch_p(T_RIGHTPAREN)]                     )                 ;
              macro_definition                 = no_node_d[*ppsp]                     >> *( anychar_p -                             (ch_p(T_NEWLINE) | ch_p(T_CPPCOMMENT) | ch_p(T_EOF))                         )                 ;
          }
          rule_type const& start() const         ;
      };
      bool &found_eof;
      TokenT &found_directive;
      ContainerT &found_eoltokens;
      cpp_grammar(bool &found_eof_, TokenT &found_directive_,             ContainerT &found_eoltokens_)     : found_eof(found_eof_),         found_directive(found_directive_),         found_eoltokens(found_eoltokens_)     {
                                ;
      }
  };
   template <typename NodeFactoryT, typename IteratorT, typename ParserT> inline boost::tree_parse_info<IteratorT, NodeFactoryT> parsetree_parse(IteratorT const& first_, IteratorT const& last,     boost::parser<ParserT> const& p) {
      using namespace boost;
      typedef pt_match_policy<IteratorT, NodeFactoryT> pt_match_policy_type;
      typedef scanner_policies<iteration_policy, pt_match_policy_type>         scanner_policies_type;
      typedef scanner<IteratorT, scanner_policies_type> scanner_type;
      scanner_policies_type policies;
      IteratorT first = first_;
      scanner_type scan(first, last, policies);
      tree_match<IteratorT, NodeFactoryT> hit = p.derived().parse(scan);
  }
   template <typename LexIteratorT, typename TokenContainerT> boost::tree_parse_info<     LexIteratorT,     typename cpp_grammar_gen<LexIteratorT, TokenContainerT>::node_factory_type > cpp_grammar_gen<LexIteratorT, TokenContainerT>::parse_cpp_grammar (     LexIteratorT const &first, LexIteratorT const &last,     position_type const &act_pos, bool &found_eof,     token_type &found_directive, token_container_type &found_eoltokens) {
      using namespace boost;
      using namespace boost;
      cpp_grammar<token_type, TokenContainerT> g(found_eof, found_directive, found_eoltokens);
      tree_parse_info<LexIteratorT, node_factory_type> hit =         parsetree_parse<node_factory_type>(first, last, g);
      return hit;
  }
   
   
   }
    typedef boost::cpplexer::lex_token<> token_type;
    typedef boost::cpplexer::lex_iterator<token_type> lexer_type;
    typedef Trans_NS___cxx11_list<token_type, boost::fast_pool_allocator<token_type> >     token_sequence_type;
    template struct __attribute__((__visibility__("default"))) boost::cpp_grammar_gen<lexer_type, token_sequence_type>;