<mangled-name> ::= _ <mangled-name2>
<mangled-name2> ::= <mangled-name3> <sem-end>
<mangled-name2> ::= _ <mangled-name3> <sem-end>
<mangled-name3> ::= Z <encoding>
<encoding> ::= <name> <bare-function-type>
<name> ::= <nested-name>
<name> ::= <source-name> <template-args>
<name> ::= S <name-sub> #deciding rule
<name-sub> ::= <sem-ssno> <substitution2-t> <unqualified-name>
<name-sub> ::= <sem-ssno> <substitution2> <template-args>
<template-args> ::= <sem-skiptempl>
<template-args> ::= <sem-begintempl> I <template-arg> <template-arg-more> E
<template-args-nostore> ::= <sem-skiptempl>
<template-args-nostore> ::= <sem-begintempl> I <template-arg-nostore> <template-arg-nostore-more> E
<template-arg-more> ::= <sem-storetemparg> <template-arg> <template-arg-more>
<template-arg-more> ::= <sem-storetemplate>
<template-arg> ::= <type>
<template-arg> ::= <expr-primary>
<template-arg-nostore> ::= <type>
<template-arg-nostore> ::= <expr-primary>
<template-arg-nostore-more> ::= <sem-storetemparg> <template-arg> <template-arg-more>
<template-arg-nostore-more> ::= <sem-templ2tftpl>
<template-param> ::= T <template-param2>
<template-param2> ::= <sem-loadtsub> _
<template-param2> ::= <sem-loadtsub> <number> _ #<unscoped-name> ::= <unqualified-name> #<unscoped-name> ::= St <unqualified-name> # unused, but may be useful in the future
<nested-name> ::= <sem-ssnest> N <CV-qualifiers> <unqualified-name> <unqualified-name-more> E
<prefix> ::= 
<prefix> ::= <substitution>
<prefix> ::= <template-param>
<unqualified-function-name> ::= <unqualified-name>
<unqualified-function-name> ::= <ctor-dtor-name> <template-args-nostore>
<unqualified-function-name> ::= <operator-name-setname>
<operator-name-setname> ::= <sem-setnameo> <operator-name> <template-args>
<operator-name-setname> ::= <sem-setnameo> <operator-name-cv>
<unqualified-name> ::= <source-name> <template-args>
<unqualified-name> ::= <substitution> <template-args>
<unqualified-name-more> ::= <unqualified-function-name> <unqualified-name-more>
<unqualified-name-more> ::= 
<source-name> ::= <source-number>
<source-number> ::= <sem-loadid> <number>
<number> ::= 0
<number> ::= 1
<number> ::= 2
<number> ::= 3
<number> ::= 4
<number> ::= 5
<number> ::= 6
<number> ::= 7
<number> ::= 8
<number> ::= 9
<ctor-dtor-name> ::= <sem-setnamec> C <ctor>
<ctor> ::= 1 # complete object constructor
<ctor> ::= 2 # base object constructor
<ctor> ::= 3 # complete object allocating constructor
<ctor-dtor-name> ::= <sem-setnamed> D <dtor>
<dtor> ::= 0 # deleting destructor
<dtor> ::= 1 # complete object destructor
<dtor> ::= 2 # base object destructor
<CV-qualifiers> ::= <r> <V> <K>
<r> ::= <sem-setrestrict> r # restrict
<r> ::=
<V> ::= <sem-setvolatile> V # volatile
<V> ::=
<K> ::= <sem-setconst> K # const
<K> ::=
<bare-function-type> ::= <sem-unq2f> <bare-function-type2>
<bare-function-type2> ::= <type> <another-type> <sem-par2f>
<bare-function-type2> ::= <sem-setnamex>
<another-type> ::= <sem-storepar> <type> <another-type>
<another-type> ::=
<type> ::= <type-qualifier> <type2>
<type-qualifier> ::= 
<type-qualifier> ::= <sem-setrestrict> r <type-qualifier>
<type-qualifier> ::= <sem-setvolatile> V <type-qualifier>
<type-qualifier> ::= <sem-setconst> K <type-qualifier>
<type-qualifier> ::= <sem-setptr> P <type-qualifier>
<type-qualifier> ::= <sem-setref> R <type-qualifier>
<type-qualifier> ::= <sem-setrval> O <type-qualifier>
<type-qualifier> ::= <sem-setcpair> C <type-qualifier>
<type-qualifier> ::= <sem-setim> G <type-qualifier>
<type2> ::= <template-param>
<type2> ::= <builtin-type>
<type2> ::= <class-enum-type>
<type2> ::= <array-type>
<array-type> ::= A <array-number> _ <type>
<array-number> ::= <sem-loadarr> <number>
<class-enum-type> ::= <name>
<builtin-type> ::= <sem-settypev> v  # void
<builtin-type> ::= <sem-settypew> w  # wchar_t
<builtin-type> ::= <sem-settypeb> b  # bool
<builtin-type> ::= <sem-settypec> c  # char
<builtin-type> ::= <sem-settypea> a  # signed char
<builtin-type> ::= <sem-settypeh> h  # unsigned char
<builtin-type> ::= <sem-settypes> s  # short
<builtin-type> ::= <sem-settypet> t  # unsigned short
<builtin-type> ::= <sem-settypei> i  # int
<builtin-type> ::= <sem-settypej> j  # unsigned int
<builtin-type> ::= <sem-settypel> l  # long
<builtin-type> ::= <sem-settypem> m  # unsigned long
<builtin-type> ::= <sem-settypex> x  # long long, __int64
<builtin-type> ::= <sem-settypey> y  # unsigned long long, __int64
<builtin-type> ::= <sem-settypen> n  # __int128
<builtin-type> ::= <sem-settypeo> o  # unsigned __int128
<builtin-type> ::= <sem-settypef> f  # float
<builtin-type> ::= <sem-settyped> d  # double
<builtin-type> ::= <sem-settypee> e  # long double, __float80
<builtin-type> ::= <sem-settypeg> g  # __float128
<builtin-type> ::= <sem-settypez> z  # ellipsis
<builtin-type> ::= D <builtin-type2>
<builtin-type2> ::= d # IEEE 754r decimal floating point (64 bits)
<builtin-type2> ::= e # IEEE 754r decimal floating point (128 bits)
<builtin-type2> ::= f # IEEE 754r decimal floating point (32 bits)
<builtin-type2> ::= h # IEEE 754r half-precision floating point (16 bits)
<builtin-type2> ::= i # char32_t
<builtin-type2> ::= s # char16_t
<builtin-type2> ::= a # auto (in dependent new-expressions)
<builtin-type2> ::= n # std::nullptr_t (i.e., decltype(nullptr))
<substitution> ::= S <subst>
<subst> ::= <substitution2-t> # separating St
<subst> ::= <substitution2>
<substitution2> ::= <seq-id> _
<substitution2> ::= <sem-loadsub> _
<seq-id> ::= <sem-loadsub> 0
<seq-id> ::= <sem-loadsub> 1
<seq-id> ::= <sem-loadsub> 2
<seq-id> ::= <sem-loadsub> 3
<seq-id> ::= <sem-loadsub> 4
<seq-id> ::= <sem-loadsub> 5
<seq-id> ::= <sem-loadsub> 6
<seq-id> ::= <sem-loadsub> 7
<seq-id> ::= <sem-loadsub> 8
<seq-id> ::= <sem-loadsub> 9
<seq-id> ::= <sem-loadsub> A
<seq-id> ::= <sem-loadsub> B
<seq-id> ::= <sem-loadsub> C
<seq-id> ::= <sem-loadsub> D
<seq-id> ::= <sem-loadsub> E
<seq-id> ::= <sem-loadsub> F
<seq-id> ::= <sem-loadsub> G
<seq-id> ::= <sem-loadsub> H
<seq-id> ::= <sem-loadsub> I
<seq-id> ::= <sem-loadsub> J
<seq-id> ::= <sem-loadsub> K
<seq-id> ::= <sem-loadsub> L
<seq-id> ::= <sem-loadsub> M
<seq-id> ::= <sem-loadsub> N
<seq-id> ::= <sem-loadsub> O
<seq-id> ::= <sem-loadsub> P
<seq-id> ::= <sem-loadsub> Q
<seq-id> ::= <sem-loadsub> R
<seq-id> ::= <sem-loadsub> S
<seq-id> ::= <sem-loadsub> T
<seq-id> ::= <sem-loadsub> U
<seq-id> ::= <sem-loadsub> V
<seq-id> ::= <sem-loadsub> W
<seq-id> ::= <sem-loadsub> X
<seq-id> ::= <sem-loadsub> Y
<seq-id> ::= <sem-loadsub> Z
<substitution2-t> ::= <sem-substd> t # ::std::
<substitution2> ::= <sem-subalc> a # ::std::allocator
<substitution2> ::= <sem-substr> b # ::std::basic_string
<substitution2> ::= <sem-substrs> s # ::std::basic_string<char,::std::char_traits<char>,::std::allocator<char>>
<substitution2> ::= <sem-subistr> i # ::std::basic_istream<char,  std::char_traits<char> >
<substitution2> ::= <sem-subostr> o # ::std::basic_ostream<char,  std::char_traits<char> >
<substitution2> ::= <sem-subiostr> d # ::std::basic_iostream<char, std::char_traits<char> >
<operator-name> ::= a <operator-name-a>
<operator-name> ::= c <operator-name-c>
<operator-name> ::= d <operator-name-d>
<operator-name> ::= e <operator-name-e>
<operator-name> ::= g <operator-name-g>
<operator-name> ::= i <operator-name-i>
<operator-name> ::= l <operator-name-l>
<operator-name> ::= m <operator-name-m>
<operator-name> ::= n <operator-name-n>
<operator-name> ::= o <operator-name-o>
<operator-name> ::= p <operator-name-p>
<operator-name> ::= q <operator-name-q>
<operator-name> ::= r <operator-name-r>
<operator-name> ::= s <operator-name-s>
<operator-name-a> ::= <sem-setopaa> a # &&     
<operator-name-a> ::= <sem-setopad> d # & (unary)     
<operator-name-a> ::= <sem-setopan> n # &      
<operator-name-a> ::= <sem-setopat> t # alignof (a type)
<operator-name-a> ::= <sem-setopaz> z # alignof (an expression)
<operator-name-a> ::= <sem-setopass> S # =      
<operator-name-a> ::= <sem-setopann> N # &=     
<operator-name-c> ::= <sem-setopcm> m # ,
<operator-name-c> ::= <sem-setopcl> l # ()     
<operator-name-c> ::= <sem-setopco> o # ~      
<operator-name-cv> ::= <sem-setopcv> v <type> <sem-par2spec> # (cast)
<operator-name-d> ::= <sem-setopdl> l # delete
<operator-name-d> ::= <sem-setopda> a # delete[]
<operator-name-d> ::= <sem-setopde> e # * (unary)
<operator-name-d> ::= <sem-setopdv> v # /      
<operator-name-d> ::= <sem-setopdvv> V # /=     
<operator-name-e> ::= <sem-setopeo> o # ^      
<operator-name-e> ::= <sem-setopeoo> O # ^=     
<operator-name-e> ::= <sem-setopeq> q # ==     
<operator-name-g> ::= <sem-setopgt> t # >      
<operator-name-g> ::= <sem-setopge> e # >=     
<operator-name-i> ::= <sem-setopix> x # []     
<operator-name-l> ::= <sem-setopls> s # <<     
<operator-name-l> ::= <sem-setoplss> S # <<=    
<operator-name-l> ::= <sem-setoplt> t # <      
<operator-name-l> ::= <sem-setople> e # <=     
<operator-name-m> ::= <sem-setopmi> i # -      
<operator-name-m> ::= <sem-setopml> l # *      
<operator-name-m> ::= <sem-setopmii> I # -=     
<operator-name-m> ::= <sem-setopmll> L # *=     
<operator-name-m> ::= <sem-setopmm> m # -- (postfix in <expression> context)    
<operator-name-n> ::= <sem-setopnw> w # new    
<operator-name-n> ::= <sem-setopna> a # new[]
<operator-name-n> ::= <sem-setopng> g # - (unary)     
<operator-name-n> ::= <sem-setopne> e # !=     
<operator-name-n> ::= <sem-setopnt> t # !      
<operator-name-o> ::= <sem-setopor> r # |      
<operator-name-o> ::= <sem-setoporr> R # |=     
<operator-name-o> ::= <sem-setopoo> o # ||     
<operator-name-p> ::= <sem-setopps> s # + (unary)
<operator-name-p> ::= <sem-setoppl> l # +      
<operator-name-p> ::= <sem-setoppll> L # +=     
<operator-name-p> ::= <sem-setoppp> p # ++ (postfix in <expression> context)
<operator-name-p> ::= <sem-setoppm> m # ->*    
<operator-name-p> ::= <sem-setoppt> t # ->     
<operator-name-q> ::= <sem-setopqu> u # ?      
<operator-name-r> ::= <sem-setoprm> m # %      
<operator-name-r> ::= <sem-setoprmm> M # %=     
<operator-name-r> ::= <sem-setoprs> s # >>     
<operator-name-r> ::= <sem-setoprss> S # >>=    
<operator-name-s> ::= <sem-setopst> t # sizeof (a type)
<operator-name-s> ::= <sem-setopsz> z # sizeof (an expression)
<expr-primary> ::= <sem-beginexpr> L <builtin-type> <sem-type2expr> <expr-number> E <sem-storeexpr>
<expr-number> ::= <sem-exprval> <number>
<sem-addchartoname> ::= 
<sem-storename> ::= 
<sem-loadid> ::= 
<sem-loadarr> ::= 
<sem-ssno> ::= 
<sem-ssnest> ::= 
<sem-stunq> ::= 
<sem-loadtsub> ::= 
<sem-type2expr> ::= 
<sem-exprval> ::= 
<sem-beginexpr> ::= 
<sem-storeexpr> ::= 
<sem-copyexpr> ::= 
<sem-storepar> ::= 
<sem-begintempl> ::= 
<sem-skiptempl> ::= 
<sem-storetemparg> ::= 
<sem-storetemplate> ::= 
<sem-setnametf> ::= 
<sem-par2f> ::= 
<sem-unq2f> ::= 
<sem-unq2p> ::= 
<sem-setnamex> ::= 
<sem-setnameo> ::= 
<sem-par2spec> ::= 
<sem-par2ret> ::=
<sem-settypev> ::= 
<sem-settypew> ::= 
<sem-settypeb> ::= 
<sem-settypec> ::= 
<sem-settypea> ::= 
<sem-settypeh> ::= 
<sem-settypes> ::= 
<sem-settypet> ::= 
<sem-settypei> ::= 
<sem-settypej> ::= 
<sem-settypel> ::= 
<sem-settypem> ::= 
<sem-settypex> ::= 
<sem-settypey> ::= 
<sem-settypen> ::= 
<sem-settypeo> ::= 
<sem-settypef> ::= 
<sem-settyped> ::= 
<sem-settypee> ::= 
<sem-settypeg> ::= 
<sem-settypez> ::= 
<sem-setrestrict> ::= 
<sem-setvolatile> ::= 
<sem-setconst> ::= 
<sem-setptr> ::= 
<sem-setref> ::= 
<sem-setrval> ::= 
<sem-setcpair> ::= 
<sem-setim> ::= 
<sem-substd> ::= 
<sem-subalc> ::= 
<sem-substr> ::= 
<sem-substrs> ::= 
<sem-subistr> ::= 
<sem-subostr> ::= 
<sem-subiostr> ::= 
<sem-loadsub> ::= 
<sem-setnamec> ::= 
<sem-setnamed> ::= 
<sem-setopnw> ::= 
<sem-setopna> ::= 
<sem-setopdl> ::= 
<sem-setopda> ::= 
<sem-setopps> ::= 
<sem-setopng> ::= 
<sem-setopad> ::= 
<sem-setopde> ::= 
<sem-setopco> ::= 
<sem-setoppl> ::= 
<sem-setopmi> ::= 
<sem-setopml> ::= 
<sem-setopdv> ::= 
<sem-setoprm> ::= 
<sem-setopan> ::= 
<sem-setopor> ::= 
<sem-setopeo> ::= 
<sem-setopass> ::= 
<sem-setoppll> ::= 
<sem-setopmii> ::= 
<sem-setopmll> ::= 
<sem-setopdvv> ::= 
<sem-setoprmm> ::= 
<sem-setopann> ::= 
<sem-setoporr> ::= 
<sem-setopeoo> ::= 
<sem-setopls> ::= 
<sem-setoprs> ::= 
<sem-setoplss> ::= 
<sem-setoprss> ::= 
<sem-setopeq> ::= 
<sem-setopne> ::= 
<sem-setoplt> ::= 
<sem-setopgt> ::= 
<sem-setople> ::= 
<sem-setopnt> ::= 
<sem-setopaa> ::= 
<sem-setopoo> ::= 
<sem-setoppp> ::= 
<sem-setopmm> ::= 
<sem-setopcm> ::= 
<sem-setoppm> ::= 
<sem-setoppt> ::= 
<sem-setopcl> ::= 
<sem-setopix> ::= 
<sem-setopge> ::=
<sem-setopqu> ::= 
<sem-setopst> ::= 
<sem-setopsz> ::= 
<sem-setopat> ::= 
<sem-setopaz> ::= 
<sem-setopcv> ::= 
<sem-setopxx> ::= 
<sem-setnamef> ::= 
<sem-setnamevt> ::= 
<sem-reversename> ::= 
<sem-setprivate> ::= 
<sem-setpublic> ::= 
<sem-setprotected> ::= 
<sem-setfcdecl> ::= 
<sem-setfpascal> ::= 
<sem-setffortran> ::= 
<sem-setfthiscall> ::= 
<sem-setfstdcall> ::= 
<sem-setffastcall> ::= 
<sem-setfinterrupt> ::= 
<sem-setunion> ::= 
<sem-setstruct> ::= 
<sem-setclass> ::= 
<sem-setenum> ::= 
<sem-setstatic> ::= 
<sem-setvirtual> ::= 
<sem-stclconst> ::= 
<sem-stclvol> ::= 
<sem-stclfar> ::= 
<sem-stclhuge> ::= 
<sem-savenamesub> ::= 
<sem-loadnamesub> ::= 
<sem-mstemplsub> ::= 
<sem-setnamer0> ::= 
<sem-setnamer1> ::= 
<sem-setnamer2> ::= 
<sem-setnamer3> ::= 
<sem-setnamer4> ::= 
<sem-setname_a> ::= 
<sem-setname_b> ::= 
<sem-setname_c> ::= 
<sem-setname_d> ::= 
<sem-setname_e> ::= 
<sem-setname_f> ::= 
<sem-setname_g> ::= 
<sem-setname_h> ::= 
<sem-setname_i> ::= 
<sem-setname_j> ::= 
<sem-setname_k> ::= 
<sem-setname_l> ::= 
<sem-setname_m> ::= 
<sem-setname_n> ::= 
<sem-setname_o> ::= 
<sem-setname_p> ::= 
<sem-setname_q> ::= 
<sem-setname_r> ::= 
<sem-setname_s> ::= 
<sem-setname_t> ::= 
<sem-setname_u> ::= 
<sem-setname_v> ::= 
<sem-setname_w> ::= 
<sem-setname_x> ::= 
<sem-setname_y> ::= 
<sem-setname_z> ::= 
<sem-templ2tftpl> ::= 
<sem-beginbsub> ::= #begin built-in substitution
<sem-loadbsub> ::= 
<sem-addmconst> ::= 
<sem-addmvol> ::= 
<sem-addmfar> ::= 
<sem-addmhuge> ::= 
<sem-loadmsnum> ::= 
<sem-numtorttibcd> ::= 
<sem-numtotype> ::= 
<sem-normalizeparname> ::= 
<sem-borlandid> ::= 
<sem-loadborlandsub> ::=
<sem-borlandarr> ::=
<sem-end> ::= 