template <typename >     struct parser     {
      };
                                 struct nil_t;
                                                               namespace Trans_NS_spirit_classic {
                              namespace template <         typename T0 = nil_t     >     class rule         {
                               template <typename ParserT>         void  operator=(ParserT const& p         ;
                           }
             template <>     class chseq : parser<int >     {
                               int last;
                           }
             class strlit : public parser<strlit >     {
                           chseq<> seq                }
                              template <typename CharT>      strlit     str_p(CharT ;
                          template<class > class __attribute__(()) basic_xml_grammar {
                            typedef rule<> rule_t;
                            rule_t         Eq,         CharRefGTNameClassNameChar,         ClassName,         ClassNameAttribute;
                                                     basic_xml_grammar()};
                          };
                                                   template <class T1, class T2>    class compressed_pair_imp    {
                            typedef T1 first_type;
                            private:       first_type first_}template <class T1, class T2> class compressed_pair    : private ::compressed_pair_imp<T1, T2> {
      }template <typename A, typename , typename BaseT>     class binary : public BaseT     {
                                                            typedef typename B::embed_t right_embed_t;
                             private:compressed_pair<A, right_embed_t> subj;
                             }
               namespace Trans_NS_spirit_classic {
                              template <typename A>     struct sequence : public binary<A, int, parser<sequence<A> > >     {
                           };
                              template <typename A, typename B>     sequence<A>     operator>>(parser<A> const, B> constb(;
                          __attribute__(()) const BOOST_ARCHIVE_XML_CLASS_NAME();
                          template<class CharType> basic_xml_grammar<CharType>::basic_xml_grammar(){
                            ClassNameAttribute =         str_p(BOOST_ARCHIVE_XML_CLASS_NAME)         >> Eq         >> L'"'         >> ClassName         >> L'"'     ;
                        }
                          template class basic_xml_grammar<char>;