fuck.cpp

#include <string>
#include <iostream>

#include <pegtl.hh>

namespace asl
{

//FUCK THIS SHIT
struct la;
struct string;
struct c;
struct integer;
struct ra;
struct ll;
struct rr;
struct end_of_file;
struct ws;
struct statement;
struct index_assignment;
struct external;
struct nameobject;
struct deviceterm;
struct macro_invocation;
struct junk;
struct namedobject;
struct assignment;
struct crement;
struct ifelseterm;
struct whileterm;
struct method_invocation;
struct returnterm;
struct block;
struct name;
struct namepath;
struct connectionterm;
struct condrefofterm;
struct continueterm;
struct eisaidterm;
struct eventterm;
struct acquireterm;
struct addterm;
struct andterm;
struct concatterm;
struct concatresterm;
struct copyobjectterm;
struct decterm;
struct derefofterm;
struct divideterm;
struct findsetleftbitterm;
struct findsetrightbitterm;
struct frombcdterm;
struct incterm;
struct indexterm;
struct landterm;
struct lequalterm;
struct lgreaterterm;
struct lgreaterequalterm;
struct llessterm;
struct llessequalterm;
struct lnotterm;
struct lnotequalterm;
struct loadtableterm;
struct lorterm;
struct matchterm;
struct midterm;
struct modterm;
struct multiplyterm;
struct nandterm;
struct norterm;
struct notterm;
struct objecttypeterm;
struct orterm;
struct printfterm;
struct refofterm;
struct shiftleftterm;
struct shiftrightterm;
struct sizeofterm;
struct storeterm;
struct subtractterm;
struct timerterm;
struct tobcdterm;
struct tobufferterm;
struct todecimalstringterm;
struct tohexstringterm;
struct tointegerterm;
struct tostringterm;
struct waitterm;
struct xorterm;
struct touuidterm;
struct unicodeterm;
struct objecttypekeyword;
struct expression;
struct primary;
struct argterm;
struct localterm;
struct assignment_operator;
struct comparative;
struct additive;
struct multitive;
struct ifterm;
struct ifelseterm;
struct elseterm;
struct elseif;
struct byteconstexpr;
struct debugterm;
struct comparative_operator;
struct additive_operator;
struct multitive_operator;
struct buffer;
struct byteconst;
struct negation;
struct trueterm;
struct falseterm;
struct package;
struct fprintfterm;
struct printfterm;
struct includeterm;
struct aliasterm;
struct scopeterm;
struct packageelement;
struct offsetterm;
struct bankfieldterm;
struct accessasterm;
struct createbitfieldterm;
struct createbytefieldterm;
struct breakterm;
struct createdwordfieldterm;
struct breakpointterm;
struct parametertypepackage;
struct parameterstypespackage;
struct fatalterm;
struct createfieldterm;
struct createqwordfieldterm;
struct loadterm;
struct createwordfieldterm;
struct noopterm;
struct dataregionterm;
struct notifyterm;
struct releaseterm;
struct signalterm;
struct sleepterm;
struct stallterm;
struct switchterm;
struct unloadterm;
struct fieldterm;
struct indexfieldterm;
struct methodterm;
struct mutexterm;
struct opregionterm;
struct powerresterm;
struct processorterm;
struct resetterm;
struct thermalzoneterm;
// END FUCK

struct ROOT
	: pegtl::seq<pegtl::string< 'D','e','f','i','n','i','t','i','o','n','B','l','o','c','k' >, la, string, c, string, c, integer, c, string, c, string, c, integer, ra, ll, block, rr> {};

struct accessattribkeyword
	: pegtl::sor<pegtl::string< 'A','t','t','r','i','b','Q','u','i','c','k' >, pegtl::string< 'A','t','t','r','i','b','S','e','n','d','R','e','c','e','i','v','e' >, pegtl::string< 'A','t','t','r','i','b','B','y','t','e' >, pegtl::string< 'A','t','t','r','i','b','B','y','t','e','s' >, pegtl::string< 'A','t','t','r','i','b','R','a','w','B','y','t','e','s' >,
    pegtl::string< 'A','t','t','r','i','b','R','a','w','P','r','o','c','e','s','s','B','y','t','e','s' >, pegtl::string< 'A','t','t','r','i','b','W','o','r','d' >, pegtl::string< 'A','t','t','r','i','b','B','l','o','c','k' >, pegtl::string< 'A','t','t','r','i','b','P','r','o','c','e','s','s','C','a','l','l' >, pegtl::string< 'A','t','t','r','i','b','B','l','o','c','k','P','r','o','c','e','s','s','C','a','l','l' >> {};

struct accesstypekeyword
	: pegtl::sor< pegtl::string< 'A','n','y','A','c','c' >, pegtl::string< 'B','y','t','e','A','c','c' >, pegtl::string< 'W','o','r','d','A','c','c' >, pegtl::string< 'D','W','o','r','d','A','c','c' >, pegtl::string< 'Q','W','o','r','d','A','c','c' >, pegtl::string< 'B','u','f','f','e','r','A','c','c' >> {};
struct addresskeyword
	: pegtl::sor< pegtl::string< 'A','d','d','r','e','s','s','R','a','n','g','e','M','e','m','o','r','y' >, pegtl::string< 'A','d','d','r','e','s','s','R','a','n','g','e','R','e','s','e','r','v','e','d' >, pegtl::string< 'A','d','d','r','e','s','s','R','a','n','g','e','N','V','S' >, pegtl::string< 'A','d','d','r','e','s','s','R','a','n','g','e','A','C','P','I' >> {};
struct addressspacekeyword
	: pegtl::sor< pegtl::string< 'R','e','g','i','o','n','S','p','a','c','e','K','e','y','w','o','r','d' >, pegtl::string< 'F','F','i','x','e','d','H','W' >, pegtl::string< 'P','C','C' >> {};
struct addressingmodekeyword
	: pegtl::sor< pegtl::string< 'A','d','d','r','e','s','s','i','n','g','M','o','d','e','7','B','i','t' >, pegtl::string< 'A','d','d','r','e','s','s','i','n','g','M','o','d','e','1','0','B','i','t' >> {};
struct bytelengthkeyword
	: pegtl::sor< pegtl::string< 'D','a','t','a','B','i','t','s','F','i','v','e' >, pegtl::string< 'D','a','t','a','B','i','t','s','S','i','x' >, pegtl::string< 'D','a','t','a','B','i','t','s','S','e','v','e','n' >, pegtl::string< 'D','a','t','a','B','i','t','s','E','i','g','h','t' >, pegtl::string< 'D','a','t','a','B','i','t','s','N','i','n','e' >> {};
struct busmasterkeyword
	: pegtl::sor< pegtl::string< 'B','u','s','M','a','s','t','e','r' >, pegtl::string< 'N','o','t','B','u','s','M','a','s','t','e','r' >> {};
struct clockphasekeyword
	: pegtl::sor< pegtl::string< 'C','l','o','c','k','P','h','a','s','e','F','i','r','s','t' >, pegtl::string< 'C','l','o','c','k','P','h','a','s','e','S','e','c','o','n','d' >> {};
struct clockpolaritykeyword
	: pegtl::sor< pegtl::string< 'C','l','o','c','k','P','o','l','a','r','i','t','y','L','o','w' >, pegtl::string< 'C','l','o','c','k','P','o','l','a','r','i','t','y','H','i','g','h' >> {};
struct decodekeyword
	: pegtl::sor< pegtl::string< 'S','u','b','D','e','c','o','d','e' >, pegtl::string< 'P','o','s','D','e','c','o','d','e' >> {};
struct endiankeyword
	: pegtl::sor< pegtl::string< 'B','i','g','E','n','d','i','a','n','i','n','g' >, pegtl::string< 'L','i','t','t','l','e','E','n','d','i','a','n' >> {};
struct extendedaccessattribkeyword
	: pegtl::sor< pegtl::string< 'A','t','t','r','i','b','B','y','t','e','s' >, pegtl::string< 'A','t','t','r','i','b','R','a','w','B','y','t','e','s' >, pegtl::string< 'A','t','t','r','i','b','R','a','w','P','r','o','c','e','s','s','B','y','t','e','s' >> {};
struct flowcontrolkeyword
	: pegtl::sor< pegtl::string< 'F','l','o','w','C','o','n','t','r','o','l','N','o','n','e' >, pegtl::string< 'F','l','o','w','C','o','n','t','r','o','l','X','o','n' >, pegtl::string< 'F','l','o','w','C','o','n','t','r','o','l','H','a','r','d','w','a','r','e' >> {};
struct interrupttypekeyword
	: pegtl::sor< pegtl::string< 'E','d','g','e' >, pegtl::string< 'L','e','v','e','l' >> {};
struct interruptlevel
	: pegtl::sor< pegtl::string< 'A','c','t','i','v','e','H','i','g','h' >, pegtl::string< 'A','c','t','i','v','e','L','o','w' >> {};
struct interruptlevelkeyword
	: pegtl::sor< pegtl::string< 'A','c','t','i','v','e','H','i','g','h' >, pegtl::string< 'A','c','t','i','v','e','L','o','w' >, pegtl::string< 'A','c','t','i','v','e','B','o','t','h' >> {};
struct iodecodekeyword
	: pegtl::sor< pegtl::string< 'D','e','c','o','d','e','1','6' >, pegtl::string< 'D','e','c','o','d','e','1','0' >> {};
struct iorestrictionkeyword
	: pegtl::sor< pegtl::string< 'I','o','R','e','s','t','r','i','c','t','i','o','n','N','o','n','e' >, pegtl::string< 'I','o','R','e','s','t','r','i','c','t','i','o','n','I','n','p','u','t','O','n','l','y' >, pegtl::string< 'I','o','R','e','s','t','r','i','c','t','i','o','n','O','u','t','p','u','t','O','n','l','y' >, pegtl::string< 'I','o','R','e','s','t','r','i','c','t','i','o','n','N','o','n','e','A','n','d','P','r','e','s','e','r','v','e' >> {};
struct lockrulekeyword
	: pegtl::sor< pegtl::string< 'L','o','c','k' >, pegtl::string< 'N','o','L','o','c','k' >> {};
struct matchopkeyword
	: pegtl::sor< pegtl::string< 'M','T','R' >, pegtl::string< 'M','E','Q' >, pegtl::string< 'M','L','E' >, pegtl::string< 'M','L','T' >, pegtl::string< 'M','G','E' >, pegtl::string< 'M','G','T' >> {};
struct maxkeyword
	: pegtl::sor< pegtl::string< 'M','a','x','F','i','x','e','d' >, pegtl::string< 'M','a','x','N','o','t','F','i','x','e','d' >> {};
struct memtypekeyword
	: pegtl::sor< pegtl::string< 'C','a','c','h','e','a','b','l','e' >, pegtl::string< 'W','r','i','t','e','C','o','m','b','i','n','i','n','g' >, pegtl::string< 'P','r','e','f','e','t','c','h','a','b','l','e' >, pegtl::string< 'N','o','n','C','a','c','h','e','a','b','l','e' >> {};
struct minkeyword
	: pegtl::sor< pegtl::string< 'M','i','n','F','i','x','e','d' >, pegtl::string< 'M','i','n','N','o','t','F','i','x','e','d' >> {};

struct objecttypekeyword
	: pegtl::sor< pegtl::string< 'U','n','k','n','o','w','n','O','b','j' >, pegtl::string< 'I','n','t','O','b','j' >, pegtl::string< 'S','t','r','O','b','j' >, pegtl::string< 'B','u','f','f','O','b','j' >, pegtl::string< 'P','k','g','O','b','j' >, pegtl::string< 'F','i','e','l','d','U','n','i','t','O','b','j' >, pegtl::string< 'D','e','v','i','c','e','O','b','j' >,
    pegtl::string< 'E','v','e','n','t','O','b','j' >, pegtl::string< 'M','e','t','h','o','d','O','b','j' >, pegtl::string< 'M','u','t','e','x','O','b','j' >, pegtl::string< 'O','p','R','e','g','i','o','n','O','b','j' >, pegtl::string< 'P','o','w','e','r','R','e','s','O','b','j' >, pegtl::string< 'P','r','o','c','e','s','s','o','r','O','b','j' >,
    pegtl::string< 'T','h','e','r','m','a','l','Z','o','n','e','O','b','j' >, pegtl::string< 'B','u','f','f','F','i','e','l','d','O','b','j' >, pegtl::string< 'D','D','B','H','a','n','d','l','e','O','b','j' >> {};

struct paritykeyword
	: pegtl::sor< pegtl::string< 'P','a','r','i','t','y','T','y','p','e','N','o','n','e' >, pegtl::string< 'P','a','r','i','t','y','T','y','p','e','S','p','a','c','e' >, pegtl::string< 'P','a','r','i','t','y','T','y','p','e','M','a','r','k' >, pegtl::string< 'P','a','r','i','t','y','T','y','p','e','O','d','d' >, pegtl::string< 'P','a','r','i','t','y','T','y','p','e','E','v','e','n' >> {};
struct pinconfigkeyword
	: pegtl::sor< pegtl::string< 'P','u','l','l','D','e','f','a','u','l','t' >, pegtl::string< 'P','u','l','l','U','p' >, pegtl::string< 'P','u','l','l','D','o','w','n' >, pegtl::string< 'P','u','l','l','N','o','n','e' >> {};
struct polaritykeyword
	: pegtl::sor< pegtl::string< 'P','o','l','a','r','i','t','y','H','i','g','h' >, pegtl::string< 'P','o','l','a','r','i','t','y','L','o','w' >> {};
struct rangetypekeyword
	: pegtl::sor< pegtl::string< 'I','S','A','O','n','l','y','R','a','n','g','e','s' >, pegtl::string< 'N','o','n','I','S','A','O','n','l','y','R','a','n','g','e','s' >, pegtl::string< 'E','n','t','i','r','e','R','a','n','g','e' >> {};
struct readwritekeyword
	: pegtl::sor< pegtl::string< 'R','e','a','d','W','r','i','t','e' >, pegtl::string< 'R','e','a','d','O','n','l','y' >> {};

struct regionspacekeyword
	: pegtl::sor< pegtl::string< 'U','s','e','r','D','e','f','R','e','g','i','o','n','S','p','a','c','e' >, pegtl::string< 'S','y','s','t','e','m','I','O' >, pegtl::string< 'S','y','s','t','e','m','M','e','m','o','r','y' >, pegtl::string< 'P','C','I','_','C','o','n','f','i','g' >, pegtl::string< 'E','m','b','e','d','d','e','d','C','o','n','t','r','o','l' >,
    pegtl::string< 'S','M','B','u','s' >, pegtl::string< 'S','y','s','t','e','m','C','M','O','S' >, pegtl::string< 'P','c','i','B','a','r','T','a','r','g','e','t' >, pegtl::string< 'I','P','M','I' >, pegtl::string< 'G','e','n','e','r','a','l','P','u','r','p','o','s','e','I','O' >, pegtl::string< 'G','e','n','e','r','i','c','S','e','r','i','a','l','B','u','s' >> {};


struct resourcetypekeyword
	: pegtl::sor< pegtl::string< 'R','e','s','o','u','r','c','e','C','o','n','s','u','m','e','r' >, pegtl::string< 'R','e','s','o','u','r','c','e','P','r','o','d','u','c','e','r' >> {};
struct serializerulekeyword
	: pegtl::sor< pegtl::string< 'S','e','r','i','a','l','i','z','e','d' >, pegtl::string< 'N','o','t','S','e','r','i','a','l','i','z','e','d' >> {};
struct sharetypekeyword
	: pegtl::sor< pegtl::string< 'S','h','a','r','e','d' >, pegtl::string< 'E','x','c','l','u','s','i','v','e' >, pegtl::string< 'S','h','a','r','e','d','A','n','d','W','a','k','e' >, pegtl::string< 'E','x','c','l','u','s','i','v','e','A','n','d','W','a','k','e' >> {};
struct slavemodekeyword
	: pegtl::sor< pegtl::string< 'C','o','n','t','r','o','l','l','e','r','I','n','i','t','i','a','t','e','d' >, pegtl::string< 'D','e','v','i','c','e','I','n','i','t','i','a','t','e','d' >> {};
struct stopbitskeyword
	: pegtl::sor< pegtl::string< 'S','t','o','p','B','i','t','s','Z','e','r','o' >, pegtl::string< 'S','t','o','p','B','i','t','s','O','n','e' >, pegtl::string< 'S','t','o','p','B','i','t','s','O','n','e','P','l','u','s','H','a','l','f' >, pegtl::string< 'S','t','o','p','B','i','t','s','T','w','o' >> {};
struct transferwidthkeyword
	: pegtl::sor< pegtl::string< 'W','i','d','t','h','8','B','i','t' >, pegtl::string< 'W','i','d','t','h','1','6','B','i','t' >, pegtl::string< 'W','i','d','t','h','3','2','B','i','t' >, pegtl::string< 'W','i','d','t','h','6','4','B','i','t' >, pegtl::string< 'W','i','d','t','h','1','2','8','B','i','t' >, pegtl::string< 'W','i','d','t','h','2','5','6','B','i','t' >> {};
struct translationkeyword
	: pegtl::sor< pegtl::string< 'S','p','a','r','s','e','T','r','a','n','s','l','a','t','i','o','n' >, pegtl::string< 'D','e','n','s','e','T','r','a','n','s','l','a','t','i','o','n' >> {};
struct typekeyword
	: pegtl::sor< pegtl::string< 'T','y','p','e','T','r','a','n','s','l','a','t','i','o','n' >, pegtl::string< 'T','y','p','e','S','t','a','t','i','c' >> {};
struct updaterulekeyword
	: pegtl::sor< pegtl::string< 'P','r','e','s','e','r','v','e' >, pegtl::string< 'W','r','i','t','e','A','s','O','n','e','s' >, pegtl::string< 'W','r','i','t','e','A','s','Z','e','r','o','s' >> {};
struct userdefregionspace
	: pegtl::seq<pegtl::string< '0' >, pegtl::one<'x', 'X'>, pegtl::one<'8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f'>, pegtl::one<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f'>> {};
struct xfertypekeyword
	: pegtl::sor< pegtl::string< 'T','r','a','n','s','f','e','r','8' >, pegtl::string< 'T','r','a','n','s','f','e','r','1','6' >, pegtl::string< 'T','r','a','n','s','f','e','r','8','_','1','6' >> {};
struct wiremodekeyword
	: pegtl::sor< pegtl::string< 'T','h','r','e','e','W','i','r','e','M','o','d','e' >, pegtl::string< 'F','o','u','r','W','i','r','e','M','o','d','e' >> {};

struct block
	: pegtl::plus<pegtl::seq<ws, statement, pegtl::opt< pegtl::string< ';' > >, ws> > {};

struct statement
	: pegtl::sor<index_assignment, external, nameobject, deviceterm, macro_invocation, junk, namedobject, assignment, crement, ifelseterm, whileterm, method_invocation, returnterm> {};

struct macro_invocation
	: pegtl::sor<connectionterm, condrefofterm, continueterm, eisaidterm, eventterm, acquireterm,
    addterm, andterm, concatterm, concatresterm, copyobjectterm, decterm, derefofterm, divideterm,
    findsetleftbitterm, findsetrightbitterm, frombcdterm, incterm, indexterm, landterm, lequalterm,
    lgreaterterm, lgreaterequalterm, llessterm, llessequalterm, lnotterm, lnotequalterm,
    loadtableterm, lorterm, matchterm, midterm, modterm, multiplyterm, nandterm, norterm,
    notterm, objecttypeterm, orterm, printfterm, refofterm, shiftleftterm, shiftrightterm,
    sizeofterm, storeterm, subtractterm, timerterm, tobcdterm, tobufferterm, todecimalstringterm,
    tohexstringterm, tointegerterm, tostringterm, waitterm, xorterm, touuidterm, unicodeterm> {};

struct external
	: pegtl::seq<pegtl::string< 'E','x','t','e','r','n','a','l' >, la, namepath, c, objecttypekeyword, ra> {};

struct returnterm
	: pegtl::seq<pegtl::string< 'R','e','t','u','r','n' >, la, expression, ra> {};

struct index_accessor
	: pegtl::seq<pegtl::string< '[' >, expression, pegtl::string< ']' >> {};

struct index_access
	: pegtl::seq<pegtl::sor<argterm, localterm, namepath>, index_accessor> {};

struct index_assignment
	: pegtl::seq<namepath, index_accessor, assignment_operator, expression> {};

struct ifelseterm
	: pegtl::seq<ifterm, pegtl::star<pegtl::sor<elseterm, elseif>>>{};

struct ifterm
	: pegtl::seq<pegtl::string< 'I','f' >, la, expression, ra, ll, pegtl::opt< block >, rr> {};

struct elseterm
	: pegtl::seq<pegtl::string< 'E','l','s','e' >, ll, pegtl::opt< block >, rr> {};

struct elseif
	: pegtl::seq<pegtl::string< 'E','l','s','e','I','f' >, la, expression, ra, ll, pegtl::opt< block >, rr> {};

struct methodterm
	: pegtl::sor<pegtl::seq<pegtl::string< 'M','e','t','h','o','d' >, la, namepath, c, byteconstexpr, c, serializerulekeyword, c, byteconstexpr, ra, ll, pegtl::opt< block >, rr>,
               pegtl::seq<pegtl::string< 'M','e','t','h','o','d' >, la, namepath, c, byteconstexpr, c, serializerulekeyword, ra, ll, pegtl::opt< block >, rr>,
               pegtl::seq<pegtl::string< 'M','e','t','h','o','d' >, la, namepath, c, byteconstexpr, ra, ll, pegtl::opt< block >, rr>> {};

struct la
	: pegtl::seq<ws, pegtl::string< '(' >, ws> {};
struct ra
	: pegtl::seq<ws, pegtl::string< ')' >, ws> {};
struct ll
	: pegtl::seq<ws, pegtl::string< '{' >, ws> {};
struct rr
	: pegtl::seq<ws, pegtl::string< '}' >, ws> {};
struct c
	: pegtl::seq<ws, pegtl::string< ',' >, ws> {};

struct ws
	: pegtl::one< ' ', '\n', '\r', 't', '\v', '\f' > {};

struct anything;
//struct end_of_file
//	: pegtl::not_one<anything> {};


struct assignment
	: pegtl::seq<pegtl::sor<localterm, argterm, namepath, debugterm>, assignment_operator, pegtl::opt< la >, expression, pegtl::opt< ra >> {};

struct comparative
	: pegtl::seq<additive, comparative_operator, additive> {};
struct additive
	: pegtl::sor<pegtl::seq<multitive, additive_operator, additive>, multitive> {};
struct multitive
	: pegtl::sor<pegtl::seq<primary, multitive_operator, multitive>, primary> {};

struct primary
	: pegtl::sor<negation, crement, method_invocation, macro_invocation, trueterm, falseterm, index_access, argterm, localterm, namepath, byteconstexpr, string, buffer, package, pegtl::seq<la, expression, ra> > {};

struct expression
	: pegtl::sor<index_access, assignment, comparative, additive, localterm, argterm, macro_invocation, method_invocation> {};
struct negation
	: pegtl::seq<pegtl::sor<pegtl::string< '!' >, pegtl::string< '~' > >, expression> {};

struct supername
	: pegtl::sor<method_invocation, localterm, argterm, debugterm, refofterm, derefofterm, index_access, namepath> {};
struct method_invocation
	: pegtl::sor<pegtl::seq<namepath, la, pegtl::star<pegtl::sor<pegtl::seq<primary, c>, primary>>, ra>, pegtl::seq<namepath, ws, pegtl::string< '(',')' >>> {};


struct compound_operator
	: pegtl::sor<pegtl::string< '+','=' >, pegtl::string< '-','=' >, pegtl::string< '*','=' >, pegtl::string< '/','=' >, pegtl::string< '%','=' >, pegtl::string< '<','<','=' >, pegtl::string< '>','>','=' >, pegtl::string< '&','=' >, pegtl::string< '|','=' >, pegtl::string< '^','=' >> {};
struct comparative_operator
	: pegtl::sor<pegtl::string< '=','=' >, pegtl::string< '!','=' >, pegtl::string< '!' >, pegtl::string< '>','=' >, pegtl::string< '<','=' >, pegtl::string< '<','<' >, pegtl::string< '>','>' >, pegtl::string< '>' >, pegtl::string< '<' >, pegtl::string< '&','&' >, pegtl::string< '&' >, pegtl::string< '|','|' >, pegtl::string< '|' >, pegtl::string< '^' >, pegtl::string< '~' >> {};

struct multitive_operator
	: pegtl::sor<pegtl::string< '*' >, pegtl::string< '/' >, pegtl::string< '%' >> {};
struct additive_operator
	: pegtl::sor<pegtl::string< '+' >, pegtl::string< '-' >> {};
struct assignment_operator
	: pegtl::sor<pegtl::string< '=' >, compound_operator> {};
struct increment_operator
	: pegtl::sor<pegtl::string< '+','+' >, pegtl::string< '-','-' >> {};
struct crement
	: pegtl::seq<supername, pegtl::sor<pegtl::string< '+','+' >, pegtl::string< '-','-' >>> {};

struct localterm
	: pegtl::sor< pegtl::string< 'L','o','c','a','l','0' >, pegtl::string< 'L','o','c','a','l','1' >, pegtl::string< 'L','o','c','a','l','2' >, pegtl::string< 'L','o','c','a','l','3' >,pegtl::string< 'L','o','c','a','l','4' >, pegtl::string< 'L','o','c','a','l','5' >, pegtl::string< 'L','o','c','a','l','6' >, pegtl::string< 'L','o','c','a','l','7' >> {};
struct argterm
	: pegtl::sor< pegtl::string< 'A','r','g','0' >, pegtl::string< 'A','r','g','1' >, pegtl::string< 'A','r','g','2' >, pegtl::string< 'A','r','g','3' >, pegtl::string< 'A','r','g','4' >, pegtl::string< 'A','r','g','5' >, pegtl::string< 'A','r','g','6' >> {};

struct nameobject
	: pegtl::seq< pegtl::string< 'N','a','m','e' >, la, namepath, c, pegtl::sor< macro_invocation, buffer, package, byteconstexpr, string >, ra> {};
struct buffer
	: pegtl::seq< pegtl::string< 'B','u','f','f','e','r' >, la, pegtl::opt< byteconstexpr >, ra, ll, pegtl::star<pegtl::sor< pegtl::seq<string, pegtl::opt< c >>, pegtl::seq< byteconst, pegtl::opt< c >>>>, rr> {};
struct package
	: pegtl::seq< pegtl::string< 'P','a','c','k','a','g','e' >, la, pegtl::opt< byteconstexpr >, ra, ll, pegtl::star< pegtl::seq< pegtl::sor< package, macro_invocation, buffer, byteconstexpr, namepath, string >, pegtl::opt< c >>>, rr> {};

struct trueterm
	: pegtl::string< 'T','r','u','e' > {};
struct falseterm
	: pegtl::string< 'F','a','l','s','e' > {};

struct zero
	: pegtl::sor<pegtl::string< 'Z','e','r','o' >, pegtl::string< '0' >> {};
struct one
	: pegtl::string< 'O','n','e' > {};
struct ones
	: pegtl::string< 'O','n','e','s' > {};

struct hex
	: pegtl::one<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f'> {};
struct hexprefix
	: pegtl::seq< pegtl::string< '0' >, pegtl::one< 'x', 'X'>> {};
struct hexidecimal
	: pegtl::seq< hexprefix, pegtl::plus<hex>> {};

struct oct
	: pegtl::one<'0', '1', '2', '3', '4', '5', '6', '7'> {};
struct octal
	: pegtl::seq< pegtl::string< '0' >, pegtl::plus<oct>> {};

struct dec
	: pegtl::one<'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'> {};
struct decimal
	: pegtl::seq<pegtl::one<'1', '2', '3', '4', '5', '6', '7', '8', '9'>, pegtl::star<dec>> {};
struct integer
	: pegtl::sor< decimal, hexidecimal, octal> {};
struct byteconstexpr
	: pegtl::sor< integer, zero,ones, one, argterm, localterm> {};

struct string
	: pegtl::sor< concatterm, derefofterm, fprintfterm, midterm, printfterm, todecimalstringterm, tohexstringterm, tostringterm, pegtl::seq<pegtl::one<'"'>, pegtl::star<pegtl::seq<pegtl::not_one<'"'>, pegtl::ascii::any>>, pegtl::one<'"'>>> {};
struct dataobject
	: pegtl::sor< package, buffer, byteconstexpr, string> {};

struct namechar
	: pegtl::one<'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','0','1','2','3','4','5','6','7','8','9','_'> {};
struct leadnamechar
	: pegtl::one<'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','_'> {};
struct name
	: pegtl::sor< pegtl::seq< leadnamechar, namechar, namechar, namechar >, pegtl::seq< leadnamechar, namechar, namechar >, pegtl::seq< leadnamechar, namechar > > {};
struct namepath
	: pegtl::sor<pegtl::seq<pegtl::opt<pegtl::sor<pegtl::one<'\\'>, pegtl::plus<pegtl::one<'^'>>>>, pegtl::sor< pegtl::seq< pegtl::plus<pegtl::seq< name, pegtl::one<'.'>>>, name>, name>>, pegtl::one<'\\'>> {};
struct compilerdirective
	: pegtl::sor< includeterm, external> {};
struct namespacemodifier
	: pegtl::sor< aliasterm, nameobject, scopeterm> {};

struct object
	: pegtl::sor< compilerdirective, namedobject, namespacemodifier> {};
struct objectlist
	: pegtl::star<object> {};

struct packageelement
	: pegtl::sor< dataobject, namepath> {};
struct packagelist
	: pegtl::seq<pegtl::star<pegtl::seq<packageelement, c>>, pegtl::opt< packageelement >> {};
struct filedunitentry
	: pegtl::seq<pegtl::opt< name >, c, byteconstexpr> {};
struct fieldunit
	: pegtl::sor< filedunitentry, offsetterm, accessasterm, connectionterm> {};
struct fieldunitlist
	: pegtl::seq< pegtl::star<pegtl::seq<fieldunit, c>>, pegtl::opt < fieldunit >> {};

struct namedobject
	: pegtl::sor< bankfieldterm, createbitfieldterm, createbytefieldterm, createdwordfieldterm, createfieldterm, createqwordfieldterm, createwordfieldterm,
    dataregionterm, deviceterm, eventterm, fieldterm, indexfieldterm, methodterm, mutexterm, opregionterm, powerresterm,
    processorterm, thermalzoneterm> {};

struct byteconst
	:  pegtl::seq< hexprefix, hex, hex> {};
struct wordconst
	:  pegtl::seq< hexprefix, hex, hex, hex, hex> {};
struct dwordconst
	: pegtl::seq< hexprefix, hex, hex, hex, hex, hex, hex, hex, hex> {};
struct qwordconst
	: pegtl::seq< hexprefix, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex, hex> {};

struct junk
	: pegtl::seq< breakterm, breakpointterm, continueterm, fatalterm, loadterm, noopterm, notifyterm, releaseterm, resetterm,
    signalterm, sleepterm, stallterm, switchterm, unloadterm > {};


//struct resourcetemplate
//	:     pegtl::string< 'R','e','s','o','u','r','c','e','T','e','m','p','l','a','t','e' >, la, ra, balanced_bracket,
//struct balanced_bracket
//	:     pegtl::string< '{' > ( [^{^}] / balanced_bracket )* pegtl::string< '}' >

struct accessasterm
	: pegtl::sor<pegtl::seq< pegtl::string< 'A','c','c','e','s','s','A','s' >, la, accesstypekeyword, c, pegtl::sor<byteconstexpr, accessattribkeyword, extendedaccessattribkeyword>, ra>, pegtl::seq<pegtl::string< 'A','c','c','e','s','s','A','s' >, la, accesstypekeyword, ra>> {};
struct acquireterm
	: pegtl::seq< pegtl::string< 'A','c','q','u','i','r','e' >, la, supername, c, wordconst, ra> {};
struct addterm
	: pegtl::seq< pegtl::string< 'A','d','d' >, la, expression, c, expression, c, primary, ra> {};
struct aliasterm
	: pegtl::seq< pegtl::string< 'A','l','i','a','s' >, la, namepath, c, namepath, ra> {};
struct andterm
	: pegtl::seq< pegtl::string< 'A','n','d' >, la, expression, c, expression, c, primary, ra> {};
struct bankfieldterm
	: pegtl::seq< pegtl::string< 'B','a','n','k','F','i','e','l','d' >, la, namepath, c, namepath, c, expression, c, accesstypekeyword, c, lockrulekeyword, c, updaterulekeyword, ra, ll, fieldunitlist, rr> {};
struct breakpointterm
	: pegtl::string< 'B','r','e','a','k','P','o','i','n','t' > {};
struct breakterm
	: pegtl::string< 'B','r','e','a','k' > {};
struct caseterm
	: pegtl::seq< pegtl::string< 'C','a','s','e' >, la, dataobject, ra, ll, block, rr> {};
struct concatresterm
	: pegtl::seq< pegtl::string< 'C','o','n','c','a','t','e','n','a','t','e','R','e','s','T','e','m','p','l','a','t','e' >, la, expression, c, expression, c, primary, c, ra> {};
struct concatterm
	: pegtl::seq< pegtl::string< 'C','o','n','c','a','t','e','n','a','t','e' >, la, expression, c, expression, c, primary, c, ra> {};
struct condrefofterm
	: pegtl::seq< pegtl::string< 'C','o','n','d','R','e','f','O','f' >, la, primary, c, primary, ra> {};
struct connectionterm
	: pegtl::seq< pegtl::string< 'C','o','n','n','e','c','t','i','o','n' >, la, namepath, ra> {};
struct continueterm
	: pegtl::string< 'C','o','n','t','i','n','u','e' > {};
struct copyobjectterm
	: pegtl::seq< pegtl::string< 'C','o','p','y','O','b','j','e','c','t' >, la, expression, c, namepath, ra> {};
struct deviceterm
	: pegtl::seq< pegtl::string< 'D','e','v','i','c','e' >, la, namepath, ra, ll, block, rr> {};
struct createbitfieldterm
	: pegtl::seq< pegtl::string< 'C','r','e','a','t','e','B','i','t','F','i','e','l','d' >, la, expression, c, expression, c, namepath, ra> {};
struct createbytefieldterm
	: pegtl::seq< pegtl::string< 'C','r','e','a','t','e','B','y','t','e','F','i','e','l','d' >, la, expression, c, expression, c, namepath, ra> {};
struct createdwordfieldterm
	: pegtl::seq< pegtl::string< 'C','r','e','a','t','e','D','W','o','r','d','F','i','e','l','d' >, la, expression, c, expression, c, namepath, ra> {};
struct createfieldterm
	: pegtl::seq< pegtl::string< 'C','r','e','a','t','e','F','i','e','l','d' >, la, expression, c, expression, c, expression, c, namepath, ra> {};
struct createqwordfieldterm
	: pegtl::seq< pegtl::string< 'C','r','e','a','t','e','Q','w','o','r','d','F','i','e','l','d' >, la, expression, c, expression, c, namepath, ra> {};
struct createwordfieldterm
	: pegtl::seq< pegtl::string< 'C','r','e','a','t','e','W','o','r','d','F','i','e','l','d' >, la, expression, c, expression, c, namepath, ra> {};
struct dataregionterm
	: pegtl::seq< pegtl::string< 'D','a','t','a','T','a','b','l','e','R','e','g','i','o','n' >, la, namepath, c, expression, c, expression, c, expression, c, ra> {};
struct debugterm
	: pegtl::string< 'D','e','b','u','g' > {};
struct decterm
	: pegtl::seq< pegtl::string< 'D','e','c','r','e','m','e','n','t' >, la, supername, ra> {};
struct defaultterm
	: pegtl::seq< pegtl::string< 'D','e','f','a','u','l','t' >, ll, block, rr> {};
struct derefofterm
	: pegtl::seq< pegtl::string< 'D','e','r','e','f','O','f' >, la, expression, ra> {};
struct divideterm
	: pegtl::seq< pegtl::string< 'D','i','v','i','d','e' >, la, pegtl::plus<pegtl::seq<expression, c>>, primary, ra> {};
struct eisaidterm
	: pegtl::seq<pegtl::sor<pegtl::string< 'E','I','S','A','I','D' >, pegtl::string< 'E','i','s','a','I','d' > >, la, string, ra> {};
struct eventterm
	: pegtl::seq< pegtl::string< 'E','v','e','n','t' >, la, namepath, ra> {};
struct fatalterm
	: pegtl::seq< pegtl::string< 'F','a','t','a','l' >, la, byteconstexpr, c, dwordconst, c, expression, c, ra> {};
struct fieldterm
	: pegtl::seq< pegtl::string< 'F','i','e','l','d' >, la, namepath, c, accesstypekeyword, c, lockrulekeyword, c, updaterulekeyword, ra, ll, fieldunitlist, rr> {};
struct findsetleftbitterm
	: pegtl::seq< pegtl::string< 'F','i','n','d','S','e','t','L','e','f','t','B','i','t' >, la, expression, c, primary, ra> {};
struct findsetrightbitterm
	: pegtl::seq< pegtl::string< 'F','i','n','d','S','e','t','R','i','g','h','t','B','i','t' >, la, expression, c, primary, ra> {};
struct fprintfterm
	: pegtl::seq< pegtl::string< 'F','p','r','i','n','t','f' >, la, expression, c, string, c, ra> {};
struct frombcdterm
	: pegtl::seq< pegtl::string< 'F','r','o','m','B','C','D' >, la, expression, c, primary, ra> {};
struct functionterm
	: pegtl::seq< pegtl::string< 'F','u','n','c','t','i','o','n' >, la, namepath, pegtl::opt<pegtl::seq<c, parametertypepackage> >, pegtl::opt<pegtl::seq<c, parameterstypespackage> >, ra, ll, block, rr> {};
struct includeterm
	: pegtl::seq< pegtl::string< 'I','n','c','l','u','d','e' >, la, string, ra> {};
struct incterm
	: pegtl::seq< pegtl::string< 'I','n','c','r','e','m','e','n','t' >, la, supername, ra> {};
struct indexfieldterm
	: pegtl::seq< pegtl::string< 'I','n','d','e','x','F','i','e','l','d' >, la, namepath, c, namepath, c, accesstypekeyword, c, lockrulekeyword, c, updaterulekeyword, ra, ll, fieldunitlist, rr> {};
struct indexterm
	:pegtl::seq<  pegtl::string< 'I','n','d','e','x' >, la, expression, c, expression, c, primary, ra> {};
struct landterm
	: pegtl::seq< pegtl::string< 'L','A','n','d' >, la, expression, c, expression, ra> {};
struct lequalterm
	: pegtl::seq< pegtl::string< 'L','E','q','u','a','l' >, la, expression, c, expression, ra> {};
struct lgreaterequalterm
	: pegtl::seq< pegtl::string< 'L','G','r','e','a','t','e','r','E','q','u','a','l' >, la, expression, c, expression, ra> {};
struct lgreaterterm
	: pegtl::seq< pegtl::string< 'L','G','r','e','a','t','e','r' >, la, expression, c, expression, ra> {};
struct llessequalterm
	: pegtl::seq< pegtl::string< 'L','L','e','s','s','E','q','u','a','l' >, la, expression, c, expression, ra> {};
struct llessterm
	: pegtl::seq< pegtl::string< 'L','L','e','s','s' >, la, expression, c, expression, ra> {};
struct lnotequalterm
	: pegtl::seq< pegtl::string< 'L','N','o','t','E','q','u','a','l' >, la, expression, c, expression, ra> {};
struct lnotterm
	: pegtl::seq< pegtl::string< 'L','N','o','t' >, la, expression, ra> {};
struct loadtableterm
	: pegtl::seq< pegtl::string< 'L','o','a','d','T','a','b','l','e' >, la, expression, c, expression, c, expression, pegtl::opt<pegtl::seq<c, expression> >, pegtl::opt<pegtl::seq<c, expression> >, pegtl::opt<pegtl::seq<c, primary>>, ra> {};
struct loadterm
	: pegtl::seq< pegtl::string< 'L','o','a','d' >, la, namepath, c, supername, ra> {};
struct lorterm
	: pegtl::seq< pegtl::string< 'L','O','r' >, la, expression, c, expression, ra> {};
struct matchterm
	: pegtl::seq< pegtl::string< 'M','a','t','c','h' >, la, expression, c, matchopkeyword, c, expression, c, matchopkeyword, c, expression, c, expression, ra> {};
struct midterm
	: pegtl::seq< pegtl::string< 'M','i','d' >, la, expression, c, expression, c, expression, c, primary, ra> {};
struct modterm
	: pegtl::seq< pegtl::string< 'M','o','d' >, expression, c, expression, c, primary, ra> {};
struct multiplyterm
	: pegtl::seq< pegtl::string< 'M','u','l','t','i','p','l','y' >, la, expression, c, expression, c, primary, ra> {};
struct mutexterm
	: pegtl::seq< pegtl::string< 'M','u','t','e','x' >, la, namepath, c, byteconstexpr, ra> {};
struct nandterm
	: pegtl::seq< pegtl::string< 'N','A','n','d' >, la, expression, c, expression, c, primary, ra> {};
struct noopterm
	: pegtl::string< 'N','o','O','p' > {};
struct norterm
	: pegtl::seq< pegtl::string< 'N','O','r' >, la, expression, c, expression, c, primary, ra> {};
struct notifyterm
	: pegtl::seq< pegtl::string< 'N','o','t','i','f','y' >, la, supername, c, expression, ra> {};
struct notterm
	: pegtl::seq< pegtl::string< 'N','o','t' >, la, expression, c, primary, ra> {};
struct objecttypeterm
	: pegtl::seq< pegtl::string< 'O','b','j','e','c','t','t','y','p','e' >, la, pegtl::sor< namepath, argterm, localterm, debugterm, refofterm, derefofterm, indexterm>, ra> {};
struct offsetterm
	: pegtl::seq< pegtl::string< 'O','f','f','s','e','t' >, la, byteconstexpr, ra> {};
struct opregionterm
	: pegtl::seq< pegtl::string< 'O','p','e','r','a','t','i','o','n','R','e','g','i','o','n' >, la, namepath, c, regionspacekeyword, c, expression, c, expression, ra> {};
struct orterm
	: pegtl::seq< pegtl::string< 'O','r' >, la, expression, c, expression, c, primary, ra> {};

struct pldkeyword
	:     pegtl::sor< pegtl::string< 'P','L','D','_','R','e','v','i','s','i','o','n' >, pegtl::string< 'P','L','D','_','I','g','n','o','r','e','C','o','l','o','r' >, pegtl::string< 'P','L','D','_','R','e','d' >, pegtl::string< 'P','L','D','_','G','r','e','e','n' >, pegtl::string< 'P','L','D','_','B','l','u','e' >,
                    pegtl::string< 'P','L','D','_','W','i','d','t','h' >, pegtl::string< 'P','L','D','_','H','e','i','g','h','t' >, pegtl::string< 'P','L','D','_','U','s','e','r','V','i','s','i','b','l','e' >, pegtl::string< 'P','L','D','_','D','o','c','k' >, pegtl::string< 'P','L','D','_','L','i','d' >, pegtl::string< 'P','L','D','_','P','a','n','e','l' >,
                    pegtl::string< 'P','L','D','_','V','e','r','t','i','c','a','l','P','o','s','i','t','i','o','n' >, pegtl::string< 'P','L','D','_','H','o','r','i','z','o','n','t','a','l','P','o','s','i','t','i','o','n' >, pegtl::string< 'P','L','D','_','S','h','a','r' >,
                    pegtl::string< 'P','L','D','_','G','r','o','u','p','O','r','i','e','n','t','a','t','i','o','n' >, pegtl::string< 'P','L','D','_','G','r','o','u','p','T','o','k','e','n' >, pegtl::string< 'P','L','D','_','G','r','o','u','p','P','o','s','i','t','i','o','n' >, pegtl::string< 'P','L','D','_','B','a','y' >,
                    pegtl::string< 'P','L','D','_','E','j','e','c','t','a','b','l','e' >, pegtl::string< 'P','L','D','_','E','j','e','c','t','R','e','q','u','i','r','e','d' >, pegtl::string< 'P','L','D','_','C','a','b','i','n','e','t','N','u','m','b','e','r' >> {};


struct pldkeywordlist
	: pegtl::sor< pegtl::seq<pldkeyword, pegtl::string< '=' >, string>, byteconstexpr, pegtl::seq<string, c, pldkeywordlist, c, pldkeyword, pegtl::string< '=' >, byteconstexpr, c, pldkeywordlist>> {};
struct powerresterm
	: pegtl::sor< pegtl::seq< pegtl::string< 'P','o','w','e','r','R','e','s','o','u','r','c','e' >, la, namepath, c, byteconstexpr>, pegtl::seq<wordconst, ra, ll, objectlist, rr>> {};
struct printfterm
	: pegtl::seq< pegtl::string< 'P','r','i','n','t','f' >, la, string, c, expression, ra> {};
struct processorterm
	: pegtl::seq< pegtl::string< 'P','r','o','c','e','s','s','o','r' >, la, namepath, c, byteconstexpr, pegtl::opt<pegtl::seq<c, dwordconst> >, pegtl::opt<pegtl::seq<c, byteconstexpr> >, ra, ll, objectlist, rr> {};
struct rawdatabufferterm
	: pegtl::seq< pegtl::string< 'R','a','w','D','a','t','a','B','u','f','f','e','r' >, la, pegtl::opt< wordconst >, ra, ll, pegtl::star<pegtl::seq<c,byteconstexpr, c>>, byteconstexpr, rr> {};
struct refofterm
	: pegtl::seq< pegtl::string< 'R','e','f','O','f' >, la, supername, ra> {};
struct releaseterm
	: pegtl::seq< pegtl::string< 'R','e','l','e','a','s','e' >, la, supername, ra> {};
struct resetterm
	: pegtl::seq< pegtl::string< 'R','e','s','e','t' >, la, supername, ra> {};
struct scopeterm
	: pegtl::seq< pegtl::string< 'S','c','o','p','e' >, la, namepath, ra, ll, block, rr> {};
struct shiftleftterm
	: pegtl::seq< pegtl::string< 'S','h','i','f','t','L','e','f','t' >, la, expression, c, expression, pegtl::opt<pegtl::seq<c, primary> >, ra> {};
struct shiftrightterm
	: pegtl::seq< pegtl::string< 'S','h','i','f','t','R','i','g','h','t' >, la, expression, c, expression, c, primary, ra> {};
struct signalterm
	: pegtl::seq< pegtl::string< 'S','i','g','n','a','l' >, la, supername, ra> {};
struct sizeofterm
	: pegtl::seq< pegtl::string< 'S','i','z','e','O','f' >, la, supername, ra> {};
struct sleepterm
	: pegtl::seq< pegtl::string< 'S','l','e','e','p' >, la, expression, ra> {};
struct stallterm
	: pegtl::seq< pegtl::string< 'S','t','a','l','l' >, la, expression, c, ra> {};
struct storeterm
	: pegtl::seq< pegtl::string< 'S','t','o','r','e' >, la, expression, c, supername, ra> {};
struct subtractterm
	: pegtl::seq< pegtl::string< 'S','u','b','t','r','a','c','t' >, la, expression, c, expression, c, primary, ra> {};
struct switchterm
	: pegtl::seq< pegtl::string< 'S','w','i','t','c','h' >, la, expression, c, ra, ll, caseterm, rr> {};
struct thermalzoneterm
	: pegtl::seq< pegtl::string< 'T','h','e','r','m','a','l','Z','o','n','e' >, la, namepath, ra, ll, objectlist, rr> {};
struct timerterm
	: pegtl::string< 'T','i','m','e','r' > {};
struct tobcdterm
	: pegtl::seq< pegtl::string< 'T','o','B','C','D' >, la, expression, c, primary, ra> {};
struct tobufferterm
	: pegtl::seq< pegtl::string< 'T','o','B','u','f','f','e','r' >, la, expression, c, primary, ra> {};
struct todecimalstringterm
	: pegtl::seq< pegtl::string< 'T','o','D','e','c','i','m','a','l','S','t','r','i','n','g' >, la, expression, c, primary, ra> {};
struct tohexstringterm
	: pegtl::seq< pegtl::string< 'T','o','H','e','x','S','t','r','i','n','g' >, la, expression, c, primary, ra> {};
struct tointegerterm
	: pegtl::seq< pegtl::string< 'T','o','I','n','t','e','g','e','r' >, la, expression, pegtl::opt<pegtl::seq<c, namepath> >, ra> {};
struct topldterm
	: pegtl::seq< pegtl::string< 'T','o','P','L','D' >, la, pldkeywordlist, ra> {};
struct tostringterm
	: pegtl::seq< pegtl::string< 'T','o','S','t','r','i','n','g' >, la ,expression, pegtl::opt<pegtl::seq<c, expression> >, ra> {};
struct touuidterm
	: pegtl::seq< pegtl::string< 'T','o','U','U','I','D' >, la, string, ra> {};
struct unicodeterm
	: pegtl::seq< pegtl::string< 'U','n','i','c','o','d','e' >, la, string, ra> {};
struct unloadterm
	: pegtl::seq< pegtl::string< 'U','n','l','o','a','d' >, la, primary, ra> {};
struct waitterm
	: pegtl::seq< pegtl::string< 'W','a','i','t' >, la, primary, c, expression, ra> {};
struct whileterm
	: pegtl::seq< pegtl::string< 'W','h','i','l','e' >, la, expression, ra, ll, block, rr> {};
struct xorterm
	: pegtl::seq< pegtl::string< 'X','O','r' >, la, expression, c, expression, c, primary, ra> {};

/* FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK
FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK
 FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK
   FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK FUCK */

  template< typename Rule >
   struct action
         : pegtl::nothing< Rule > {};

}

// FUCK

int main( int argc, char * argv[] )
{
	std::cout << "Good bye, " << &pegtl::parse_arg< asl::ROOT> << "you motherfucker!" << std::endl;
}