template class a;
  template < typename c > struct e {
    typedef c embed_t c derived() const }
  struct f {
    static const int value = 0 }
  template < class s, class, int > class ai {
    s q }
  template < class s, class t > class aj : ai < s, t, f::value {
  }
  template < typename h, typename i, typename b > class av : public b {
    typedef typename h::embed_t d aj< d, i > subj }
  namespace aw {
    class ak;
  template < typename , typename > class l : public e< aw::ak > {
      typename p   }
  class ak : public l< ak, int > {
    }
  template < class af > struct al {
      typedef af *ax   }
  template < class af > class m {
    public     typename al< af >::ax operator->()   }
  template < class af > class x {
    public     m< af > am()   }
  template < typename, typename > struct an;
    template < typename aa, typename > struct u {
      typedef typename aa::ay< int > ax   }
  namespace impl {
      template < typename aa, typename c, typename ab > struct n {
       typedef aa ac typedef typename u< c, ab >::ax ao typedef aw::x< n > o                define(ac const* v         {
         ao(v->derived())}
      }
  template < typename c, typename ad, typename >     typename c : ay< int > ae() {
        an< c, ad > ap;
        typedef n< an< c, ad >, c, int > y;
        typename y : o helper;
         helper.am()->define(&ap)     }
               template<int , typename c, typename ad>     az(         an<c, ad> * ,          {
        ae< c, c, int >()         }
    }
    template < typename c, typename = int > struct an : public e< c > {
               ba( j {
           impl::az<0>(this, j)      }
               ( j)      {
        ba(j)}
    }
  template < typename h, typename i >   struct alternative : public av< h, i, e< alternative< h, i > > > {
  }
   template <typename h, typename i>     alternative<h, i>     operator|(e<h> , i  ;
                 template <typename aq, typename > struct __attribute__(()) w {
               typedef aq k          ar (k const &, k const &,         const &,  &,          &, &}
              struct r :an<r > {
      template < typename > struct ay {
                  typedef             ak                              rule_type             rule_type pp_statement              rule_type as             rule_type at , ag,               ah             ay(r          {
         pp_statement | ag | at | as | ah         }
      }
               }
             template <typename aq, typename z> w<aq, z>::ar (     aq const &first, aq const &,      const &, &,      &,  &{
      r g;
     }
             typedef a au;
             typedef int     token_sequence_type;
             template struct w<au, token_sequence_type>;