1. Enable Execution Order Tool in Build Tool project. This tool is used to statically...
authorhchen30 <hchen30@c2973edb-eda0-4c78-bc6a-9341b269661f>
Sat, 23 Jan 2010 17:25:56 +0000 (17:25 +0000)
committerhchen30 <hchen30@c2973edb-eda0-4c78-bc6a-9341b269661f>
Sat, 23 Jan 2010 17:25:56 +0000 (17:25 +0000)
git-svn-id: https://edk2-buildtools.svn.sourceforge.net/svnroot/edk2-buildtools/trunk/BaseTools@1812 c2973edb-eda0-4c78-bc6a-9341b269661f

19 files changed:
Source/Python/Eot/CLexer.py [new file with mode: 0644]
Source/Python/Eot/CParser.py [new file with mode: 0644]
Source/Python/Eot/CodeFragment.py [new file with mode: 0644]
Source/Python/Eot/CodeFragmentCollector.py [new file with mode: 0644]
Source/Python/Eot/Database.py [new file with mode: 0644]
Source/Python/Eot/EfiCompressor.pyd [new file with mode: 0644]
Source/Python/Eot/Eot.py [new file with mode: 0644]
Source/Python/Eot/EotGlobalData.py [new file with mode: 0644]
Source/Python/Eot/EotToolError.py [new file with mode: 0644]
Source/Python/Eot/FileProfile.py [new file with mode: 0644]
Source/Python/Eot/FvImage.py [new file with mode: 0644]
Source/Python/Eot/InfParserLite.py [new file with mode: 0644]
Source/Python/Eot/LzmaCompressor.pyd [new file with mode: 0644]
Source/Python/Eot/Parser.py [new file with mode: 0644]
Source/Python/Eot/ParserWarning.py [new file with mode: 0644]
Source/Python/Eot/Report.py [new file with mode: 0644]
Source/Python/Eot/__init__.py [new file with mode: 0644]
Source/Python/Eot/c.py [new file with mode: 0644]
Source/Python/Table/TableQuery.py

diff --git a/Source/Python/Eot/CLexer.py b/Source/Python/Eot/CLexer.py
new file mode 100644 (file)
index 0000000..3e2fd35
--- /dev/null
@@ -0,0 +1,4852 @@
+# $ANTLR 3.0.1 C.g 2008-06-04 15:55:54
+
+from antlr3 import *
+from antlr3.compat import set, frozenset
+
+
+# for convenience in actions
+HIDDEN = BaseRecognizer.HIDDEN
+
+# token types
+T114=114
+T115=115
+FloatTypeSuffix=16
+LETTER=11
+T29=29
+T28=28
+T27=27
+T26=26
+T25=25
+EOF=-1
+STRING_LITERAL=9
+FLOATING_POINT_LITERAL=10
+T38=38
+T37=37
+T39=39
+T34=34
+COMMENT=22
+T33=33
+T36=36
+T35=35
+T30=30
+T32=32
+T31=31
+LINE_COMMENT=23
+IntegerTypeSuffix=14
+CHARACTER_LITERAL=8
+T49=49
+T48=48
+T100=100
+T43=43
+T42=42
+T102=102
+T41=41
+T101=101
+T40=40
+T47=47
+T46=46
+T45=45
+T44=44
+T109=109
+T107=107
+T108=108
+T105=105
+WS=19
+T106=106
+T103=103
+T104=104
+T50=50
+LINE_COMMAND=24
+T59=59
+T113=113
+T52=52
+T112=112
+T51=51
+T111=111
+T54=54
+T110=110
+EscapeSequence=12
+DECIMAL_LITERAL=7
+T53=53
+T56=56
+T55=55
+T58=58
+T57=57
+T75=75
+T76=76
+T73=73
+T74=74
+T79=79
+T77=77
+T78=78
+Exponent=15
+HexDigit=13
+T72=72
+T71=71
+T70=70
+T62=62
+T63=63
+T64=64
+T65=65
+T66=66
+T67=67
+T68=68
+T69=69
+IDENTIFIER=4
+UnicodeVocabulary=21
+HEX_LITERAL=5
+T61=61
+T60=60
+T99=99
+T97=97
+BS=20
+T98=98
+T95=95
+T96=96
+OCTAL_LITERAL=6
+T94=94
+Tokens=116
+T93=93
+T92=92
+T91=91
+T90=90
+T88=88
+T89=89
+T84=84
+T85=85
+T86=86
+T87=87
+UnicodeEscape=18
+T81=81
+T80=80
+T83=83
+OctalEscape=17
+T82=82
+
+class CLexer(Lexer):
+
+    grammarFileName = "C.g"
+
+    def __init__(self, input=None):
+        Lexer.__init__(self, input)
+        self.dfa25 = self.DFA25(
+            self, 25,
+            eot = self.DFA25_eot,
+            eof = self.DFA25_eof,
+            min = self.DFA25_min,
+            max = self.DFA25_max,
+            accept = self.DFA25_accept,
+            special = self.DFA25_special,
+            transition = self.DFA25_transition
+            )
+        self.dfa35 = self.DFA35(
+            self, 35,
+            eot = self.DFA35_eot,
+            eof = self.DFA35_eof,
+            min = self.DFA35_min,
+            max = self.DFA35_max,
+            accept = self.DFA35_accept,
+            special = self.DFA35_special,
+            transition = self.DFA35_transition
+            )
+
+
+
+
+
+
+    # $ANTLR start T25
+    def mT25(self, ):
+
+        try:
+            self.type = T25
+
+            # C.g:7:5: ( ';' )
+            # C.g:7:7: ';'
+            self.match(u';')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T25
+
+
+
+    # $ANTLR start T26
+    def mT26(self, ):
+
+        try:
+            self.type = T26
+
+            # C.g:8:5: ( 'typedef' )
+            # C.g:8:7: 'typedef'
+            self.match("typedef")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T26
+
+
+
+    # $ANTLR start T27
+    def mT27(self, ):
+
+        try:
+            self.type = T27
+
+            # C.g:9:5: ( ',' )
+            # C.g:9:7: ','
+            self.match(u',')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T27
+
+
+
+    # $ANTLR start T28
+    def mT28(self, ):
+
+        try:
+            self.type = T28
+
+            # C.g:10:5: ( '=' )
+            # C.g:10:7: '='
+            self.match(u'=')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T28
+
+
+
+    # $ANTLR start T29
+    def mT29(self, ):
+
+        try:
+            self.type = T29
+
+            # C.g:11:5: ( 'extern' )
+            # C.g:11:7: 'extern'
+            self.match("extern")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T29
+
+
+
+    # $ANTLR start T30
+    def mT30(self, ):
+
+        try:
+            self.type = T30
+
+            # C.g:12:5: ( 'static' )
+            # C.g:12:7: 'static'
+            self.match("static")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T30
+
+
+
+    # $ANTLR start T31
+    def mT31(self, ):
+
+        try:
+            self.type = T31
+
+            # C.g:13:5: ( 'auto' )
+            # C.g:13:7: 'auto'
+            self.match("auto")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T31
+
+
+
+    # $ANTLR start T32
+    def mT32(self, ):
+
+        try:
+            self.type = T32
+
+            # C.g:14:5: ( 'register' )
+            # C.g:14:7: 'register'
+            self.match("register")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T32
+
+
+
+    # $ANTLR start T33
+    def mT33(self, ):
+
+        try:
+            self.type = T33
+
+            # C.g:15:5: ( 'STATIC' )
+            # C.g:15:7: 'STATIC'
+            self.match("STATIC")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T33
+
+
+
+    # $ANTLR start T34
+    def mT34(self, ):
+
+        try:
+            self.type = T34
+
+            # C.g:16:5: ( 'void' )
+            # C.g:16:7: 'void'
+            self.match("void")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T34
+
+
+
+    # $ANTLR start T35
+    def mT35(self, ):
+
+        try:
+            self.type = T35
+
+            # C.g:17:5: ( 'char' )
+            # C.g:17:7: 'char'
+            self.match("char")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T35
+
+
+
+    # $ANTLR start T36
+    def mT36(self, ):
+
+        try:
+            self.type = T36
+
+            # C.g:18:5: ( 'short' )
+            # C.g:18:7: 'short'
+            self.match("short")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T36
+
+
+
+    # $ANTLR start T37
+    def mT37(self, ):
+
+        try:
+            self.type = T37
+
+            # C.g:19:5: ( 'int' )
+            # C.g:19:7: 'int'
+            self.match("int")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T37
+
+
+
+    # $ANTLR start T38
+    def mT38(self, ):
+
+        try:
+            self.type = T38
+
+            # C.g:20:5: ( 'long' )
+            # C.g:20:7: 'long'
+            self.match("long")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T38
+
+
+
+    # $ANTLR start T39
+    def mT39(self, ):
+
+        try:
+            self.type = T39
+
+            # C.g:21:5: ( 'float' )
+            # C.g:21:7: 'float'
+            self.match("float")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T39
+
+
+
+    # $ANTLR start T40
+    def mT40(self, ):
+
+        try:
+            self.type = T40
+
+            # C.g:22:5: ( 'double' )
+            # C.g:22:7: 'double'
+            self.match("double")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T40
+
+
+
+    # $ANTLR start T41
+    def mT41(self, ):
+
+        try:
+            self.type = T41
+
+            # C.g:23:5: ( 'signed' )
+            # C.g:23:7: 'signed'
+            self.match("signed")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T41
+
+
+
+    # $ANTLR start T42
+    def mT42(self, ):
+
+        try:
+            self.type = T42
+
+            # C.g:24:5: ( 'unsigned' )
+            # C.g:24:7: 'unsigned'
+            self.match("unsigned")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T42
+
+
+
+    # $ANTLR start T43
+    def mT43(self, ):
+
+        try:
+            self.type = T43
+
+            # C.g:25:5: ( '{' )
+            # C.g:25:7: '{'
+            self.match(u'{')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T43
+
+
+
+    # $ANTLR start T44
+    def mT44(self, ):
+
+        try:
+            self.type = T44
+
+            # C.g:26:5: ( '}' )
+            # C.g:26:7: '}'
+            self.match(u'}')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T44
+
+
+
+    # $ANTLR start T45
+    def mT45(self, ):
+
+        try:
+            self.type = T45
+
+            # C.g:27:5: ( 'struct' )
+            # C.g:27:7: 'struct'
+            self.match("struct")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T45
+
+
+
+    # $ANTLR start T46
+    def mT46(self, ):
+
+        try:
+            self.type = T46
+
+            # C.g:28:5: ( 'union' )
+            # C.g:28:7: 'union'
+            self.match("union")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T46
+
+
+
+    # $ANTLR start T47
+    def mT47(self, ):
+
+        try:
+            self.type = T47
+
+            # C.g:29:5: ( ':' )
+            # C.g:29:7: ':'
+            self.match(u':')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T47
+
+
+
+    # $ANTLR start T48
+    def mT48(self, ):
+
+        try:
+            self.type = T48
+
+            # C.g:30:5: ( 'enum' )
+            # C.g:30:7: 'enum'
+            self.match("enum")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T48
+
+
+
+    # $ANTLR start T49
+    def mT49(self, ):
+
+        try:
+            self.type = T49
+
+            # C.g:31:5: ( 'const' )
+            # C.g:31:7: 'const'
+            self.match("const")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T49
+
+
+
+    # $ANTLR start T50
+    def mT50(self, ):
+
+        try:
+            self.type = T50
+
+            # C.g:32:5: ( 'volatile' )
+            # C.g:32:7: 'volatile'
+            self.match("volatile")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T50
+
+
+
+    # $ANTLR start T51
+    def mT51(self, ):
+
+        try:
+            self.type = T51
+
+            # C.g:33:5: ( 'IN' )
+            # C.g:33:7: 'IN'
+            self.match("IN")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T51
+
+
+
+    # $ANTLR start T52
+    def mT52(self, ):
+
+        try:
+            self.type = T52
+
+            # C.g:34:5: ( 'OUT' )
+            # C.g:34:7: 'OUT'
+            self.match("OUT")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T52
+
+
+
+    # $ANTLR start T53
+    def mT53(self, ):
+
+        try:
+            self.type = T53
+
+            # C.g:35:5: ( 'OPTIONAL' )
+            # C.g:35:7: 'OPTIONAL'
+            self.match("OPTIONAL")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T53
+
+
+
+    # $ANTLR start T54
+    def mT54(self, ):
+
+        try:
+            self.type = T54
+
+            # C.g:36:5: ( 'CONST' )
+            # C.g:36:7: 'CONST'
+            self.match("CONST")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T54
+
+
+
+    # $ANTLR start T55
+    def mT55(self, ):
+
+        try:
+            self.type = T55
+
+            # C.g:37:5: ( 'UNALIGNED' )
+            # C.g:37:7: 'UNALIGNED'
+            self.match("UNALIGNED")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T55
+
+
+
+    # $ANTLR start T56
+    def mT56(self, ):
+
+        try:
+            self.type = T56
+
+            # C.g:38:5: ( 'VOLATILE' )
+            # C.g:38:7: 'VOLATILE'
+            self.match("VOLATILE")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T56
+
+
+
+    # $ANTLR start T57
+    def mT57(self, ):
+
+        try:
+            self.type = T57
+
+            # C.g:39:5: ( 'GLOBAL_REMOVE_IF_UNREFERENCED' )
+            # C.g:39:7: 'GLOBAL_REMOVE_IF_UNREFERENCED'
+            self.match("GLOBAL_REMOVE_IF_UNREFERENCED")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T57
+
+
+
+    # $ANTLR start T58
+    def mT58(self, ):
+
+        try:
+            self.type = T58
+
+            # C.g:40:5: ( 'EFIAPI' )
+            # C.g:40:7: 'EFIAPI'
+            self.match("EFIAPI")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T58
+
+
+
+    # $ANTLR start T59
+    def mT59(self, ):
+
+        try:
+            self.type = T59
+
+            # C.g:41:5: ( 'EFI_BOOTSERVICE' )
+            # C.g:41:7: 'EFI_BOOTSERVICE'
+            self.match("EFI_BOOTSERVICE")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T59
+
+
+
+    # $ANTLR start T60
+    def mT60(self, ):
+
+        try:
+            self.type = T60
+
+            # C.g:42:5: ( 'EFI_RUNTIMESERVICE' )
+            # C.g:42:7: 'EFI_RUNTIMESERVICE'
+            self.match("EFI_RUNTIMESERVICE")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T60
+
+
+
+    # $ANTLR start T61
+    def mT61(self, ):
+
+        try:
+            self.type = T61
+
+            # C.g:43:5: ( '(' )
+            # C.g:43:7: '('
+            self.match(u'(')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T61
+
+
+
+    # $ANTLR start T62
+    def mT62(self, ):
+
+        try:
+            self.type = T62
+
+            # C.g:44:5: ( ')' )
+            # C.g:44:7: ')'
+            self.match(u')')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T62
+
+
+
+    # $ANTLR start T63
+    def mT63(self, ):
+
+        try:
+            self.type = T63
+
+            # C.g:45:5: ( '[' )
+            # C.g:45:7: '['
+            self.match(u'[')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T63
+
+
+
+    # $ANTLR start T64
+    def mT64(self, ):
+
+        try:
+            self.type = T64
+
+            # C.g:46:5: ( ']' )
+            # C.g:46:7: ']'
+            self.match(u']')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T64
+
+
+
+    # $ANTLR start T65
+    def mT65(self, ):
+
+        try:
+            self.type = T65
+
+            # C.g:47:5: ( '*' )
+            # C.g:47:7: '*'
+            self.match(u'*')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T65
+
+
+
+    # $ANTLR start T66
+    def mT66(self, ):
+
+        try:
+            self.type = T66
+
+            # C.g:48:5: ( '...' )
+            # C.g:48:7: '...'
+            self.match("...")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T66
+
+
+
+    # $ANTLR start T67
+    def mT67(self, ):
+
+        try:
+            self.type = T67
+
+            # C.g:49:5: ( '+' )
+            # C.g:49:7: '+'
+            self.match(u'+')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T67
+
+
+
+    # $ANTLR start T68
+    def mT68(self, ):
+
+        try:
+            self.type = T68
+
+            # C.g:50:5: ( '-' )
+            # C.g:50:7: '-'
+            self.match(u'-')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T68
+
+
+
+    # $ANTLR start T69
+    def mT69(self, ):
+
+        try:
+            self.type = T69
+
+            # C.g:51:5: ( '/' )
+            # C.g:51:7: '/'
+            self.match(u'/')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T69
+
+
+
+    # $ANTLR start T70
+    def mT70(self, ):
+
+        try:
+            self.type = T70
+
+            # C.g:52:5: ( '%' )
+            # C.g:52:7: '%'
+            self.match(u'%')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T70
+
+
+
+    # $ANTLR start T71
+    def mT71(self, ):
+
+        try:
+            self.type = T71
+
+            # C.g:53:5: ( '++' )
+            # C.g:53:7: '++'
+            self.match("++")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T71
+
+
+
+    # $ANTLR start T72
+    def mT72(self, ):
+
+        try:
+            self.type = T72
+
+            # C.g:54:5: ( '--' )
+            # C.g:54:7: '--'
+            self.match("--")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T72
+
+
+
+    # $ANTLR start T73
+    def mT73(self, ):
+
+        try:
+            self.type = T73
+
+            # C.g:55:5: ( 'sizeof' )
+            # C.g:55:7: 'sizeof'
+            self.match("sizeof")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T73
+
+
+
+    # $ANTLR start T74
+    def mT74(self, ):
+
+        try:
+            self.type = T74
+
+            # C.g:56:5: ( '.' )
+            # C.g:56:7: '.'
+            self.match(u'.')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T74
+
+
+
+    # $ANTLR start T75
+    def mT75(self, ):
+
+        try:
+            self.type = T75
+
+            # C.g:57:5: ( '->' )
+            # C.g:57:7: '->'
+            self.match("->")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T75
+
+
+
+    # $ANTLR start T76
+    def mT76(self, ):
+
+        try:
+            self.type = T76
+
+            # C.g:58:5: ( '&' )
+            # C.g:58:7: '&'
+            self.match(u'&')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T76
+
+
+
+    # $ANTLR start T77
+    def mT77(self, ):
+
+        try:
+            self.type = T77
+
+            # C.g:59:5: ( '~' )
+            # C.g:59:7: '~'
+            self.match(u'~')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T77
+
+
+
+    # $ANTLR start T78
+    def mT78(self, ):
+
+        try:
+            self.type = T78
+
+            # C.g:60:5: ( '!' )
+            # C.g:60:7: '!'
+            self.match(u'!')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T78
+
+
+
+    # $ANTLR start T79
+    def mT79(self, ):
+
+        try:
+            self.type = T79
+
+            # C.g:61:5: ( '*=' )
+            # C.g:61:7: '*='
+            self.match("*=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T79
+
+
+
+    # $ANTLR start T80
+    def mT80(self, ):
+
+        try:
+            self.type = T80
+
+            # C.g:62:5: ( '/=' )
+            # C.g:62:7: '/='
+            self.match("/=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T80
+
+
+
+    # $ANTLR start T81
+    def mT81(self, ):
+
+        try:
+            self.type = T81
+
+            # C.g:63:5: ( '%=' )
+            # C.g:63:7: '%='
+            self.match("%=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T81
+
+
+
+    # $ANTLR start T82
+    def mT82(self, ):
+
+        try:
+            self.type = T82
+
+            # C.g:64:5: ( '+=' )
+            # C.g:64:7: '+='
+            self.match("+=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T82
+
+
+
+    # $ANTLR start T83
+    def mT83(self, ):
+
+        try:
+            self.type = T83
+
+            # C.g:65:5: ( '-=' )
+            # C.g:65:7: '-='
+            self.match("-=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T83
+
+
+
+    # $ANTLR start T84
+    def mT84(self, ):
+
+        try:
+            self.type = T84
+
+            # C.g:66:5: ( '<<=' )
+            # C.g:66:7: '<<='
+            self.match("<<=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T84
+
+
+
+    # $ANTLR start T85
+    def mT85(self, ):
+
+        try:
+            self.type = T85
+
+            # C.g:67:5: ( '>>=' )
+            # C.g:67:7: '>>='
+            self.match(">>=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T85
+
+
+
+    # $ANTLR start T86
+    def mT86(self, ):
+
+        try:
+            self.type = T86
+
+            # C.g:68:5: ( '&=' )
+            # C.g:68:7: '&='
+            self.match("&=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T86
+
+
+
+    # $ANTLR start T87
+    def mT87(self, ):
+
+        try:
+            self.type = T87
+
+            # C.g:69:5: ( '^=' )
+            # C.g:69:7: '^='
+            self.match("^=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T87
+
+
+
+    # $ANTLR start T88
+    def mT88(self, ):
+
+        try:
+            self.type = T88
+
+            # C.g:70:5: ( '|=' )
+            # C.g:70:7: '|='
+            self.match("|=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T88
+
+
+
+    # $ANTLR start T89
+    def mT89(self, ):
+
+        try:
+            self.type = T89
+
+            # C.g:71:5: ( '?' )
+            # C.g:71:7: '?'
+            self.match(u'?')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T89
+
+
+
+    # $ANTLR start T90
+    def mT90(self, ):
+
+        try:
+            self.type = T90
+
+            # C.g:72:5: ( '||' )
+            # C.g:72:7: '||'
+            self.match("||")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T90
+
+
+
+    # $ANTLR start T91
+    def mT91(self, ):
+
+        try:
+            self.type = T91
+
+            # C.g:73:5: ( '&&' )
+            # C.g:73:7: '&&'
+            self.match("&&")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T91
+
+
+
+    # $ANTLR start T92
+    def mT92(self, ):
+
+        try:
+            self.type = T92
+
+            # C.g:74:5: ( '|' )
+            # C.g:74:7: '|'
+            self.match(u'|')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T92
+
+
+
+    # $ANTLR start T93
+    def mT93(self, ):
+
+        try:
+            self.type = T93
+
+            # C.g:75:5: ( '^' )
+            # C.g:75:7: '^'
+            self.match(u'^')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T93
+
+
+
+    # $ANTLR start T94
+    def mT94(self, ):
+
+        try:
+            self.type = T94
+
+            # C.g:76:5: ( '==' )
+            # C.g:76:7: '=='
+            self.match("==")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T94
+
+
+
+    # $ANTLR start T95
+    def mT95(self, ):
+
+        try:
+            self.type = T95
+
+            # C.g:77:5: ( '!=' )
+            # C.g:77:7: '!='
+            self.match("!=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T95
+
+
+
+    # $ANTLR start T96
+    def mT96(self, ):
+
+        try:
+            self.type = T96
+
+            # C.g:78:5: ( '<' )
+            # C.g:78:7: '<'
+            self.match(u'<')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T96
+
+
+
+    # $ANTLR start T97
+    def mT97(self, ):
+
+        try:
+            self.type = T97
+
+            # C.g:79:5: ( '>' )
+            # C.g:79:7: '>'
+            self.match(u'>')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T97
+
+
+
+    # $ANTLR start T98
+    def mT98(self, ):
+
+        try:
+            self.type = T98
+
+            # C.g:80:5: ( '<=' )
+            # C.g:80:7: '<='
+            self.match("<=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T98
+
+
+
+    # $ANTLR start T99
+    def mT99(self, ):
+
+        try:
+            self.type = T99
+
+            # C.g:81:5: ( '>=' )
+            # C.g:81:7: '>='
+            self.match(">=")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T99
+
+
+
+    # $ANTLR start T100
+    def mT100(self, ):
+
+        try:
+            self.type = T100
+
+            # C.g:82:6: ( '<<' )
+            # C.g:82:8: '<<'
+            self.match("<<")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T100
+
+
+
+    # $ANTLR start T101
+    def mT101(self, ):
+
+        try:
+            self.type = T101
+
+            # C.g:83:6: ( '>>' )
+            # C.g:83:8: '>>'
+            self.match(">>")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T101
+
+
+
+    # $ANTLR start T102
+    def mT102(self, ):
+
+        try:
+            self.type = T102
+
+            # C.g:84:6: ( '_asm' )
+            # C.g:84:8: '_asm'
+            self.match("_asm")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T102
+
+
+
+    # $ANTLR start T103
+    def mT103(self, ):
+
+        try:
+            self.type = T103
+
+            # C.g:85:6: ( '__asm' )
+            # C.g:85:8: '__asm'
+            self.match("__asm")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T103
+
+
+
+    # $ANTLR start T104
+    def mT104(self, ):
+
+        try:
+            self.type = T104
+
+            # C.g:86:6: ( 'case' )
+            # C.g:86:8: 'case'
+            self.match("case")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T104
+
+
+
+    # $ANTLR start T105
+    def mT105(self, ):
+
+        try:
+            self.type = T105
+
+            # C.g:87:6: ( 'default' )
+            # C.g:87:8: 'default'
+            self.match("default")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T105
+
+
+
+    # $ANTLR start T106
+    def mT106(self, ):
+
+        try:
+            self.type = T106
+
+            # C.g:88:6: ( 'if' )
+            # C.g:88:8: 'if'
+            self.match("if")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T106
+
+
+
+    # $ANTLR start T107
+    def mT107(self, ):
+
+        try:
+            self.type = T107
+
+            # C.g:89:6: ( 'else' )
+            # C.g:89:8: 'else'
+            self.match("else")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T107
+
+
+
+    # $ANTLR start T108
+    def mT108(self, ):
+
+        try:
+            self.type = T108
+
+            # C.g:90:6: ( 'switch' )
+            # C.g:90:8: 'switch'
+            self.match("switch")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T108
+
+
+
+    # $ANTLR start T109
+    def mT109(self, ):
+
+        try:
+            self.type = T109
+
+            # C.g:91:6: ( 'while' )
+            # C.g:91:8: 'while'
+            self.match("while")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T109
+
+
+
+    # $ANTLR start T110
+    def mT110(self, ):
+
+        try:
+            self.type = T110
+
+            # C.g:92:6: ( 'do' )
+            # C.g:92:8: 'do'
+            self.match("do")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T110
+
+
+
+    # $ANTLR start T111
+    def mT111(self, ):
+
+        try:
+            self.type = T111
+
+            # C.g:93:6: ( 'for' )
+            # C.g:93:8: 'for'
+            self.match("for")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T111
+
+
+
+    # $ANTLR start T112
+    def mT112(self, ):
+
+        try:
+            self.type = T112
+
+            # C.g:94:6: ( 'goto' )
+            # C.g:94:8: 'goto'
+            self.match("goto")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T112
+
+
+
+    # $ANTLR start T113
+    def mT113(self, ):
+
+        try:
+            self.type = T113
+
+            # C.g:95:6: ( 'continue' )
+            # C.g:95:8: 'continue'
+            self.match("continue")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T113
+
+
+
+    # $ANTLR start T114
+    def mT114(self, ):
+
+        try:
+            self.type = T114
+
+            # C.g:96:6: ( 'break' )
+            # C.g:96:8: 'break'
+            self.match("break")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T114
+
+
+
+    # $ANTLR start T115
+    def mT115(self, ):
+
+        try:
+            self.type = T115
+
+            # C.g:97:6: ( 'return' )
+            # C.g:97:8: 'return'
+            self.match("return")
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end T115
+
+
+
+    # $ANTLR start IDENTIFIER
+    def mIDENTIFIER(self, ):
+
+        try:
+            self.type = IDENTIFIER
+
+            # C.g:534:2: ( LETTER ( LETTER | '0' .. '9' )* )
+            # C.g:534:4: LETTER ( LETTER | '0' .. '9' )*
+            self.mLETTER()
+
+            # C.g:534:11: ( LETTER | '0' .. '9' )*
+            while True: #loop1
+                alt1 = 2
+                LA1_0 = self.input.LA(1)
+
+                if (LA1_0 == u'$' or (u'0' <= LA1_0 <= u'9') or (u'A' <= LA1_0 <= u'Z') or LA1_0 == u'_' or (u'a' <= LA1_0 <= u'z')) :
+                    alt1 = 1
+
+
+                if alt1 == 1:
+                    # C.g:
+                    if self.input.LA(1) == u'$' or (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'):
+                        self.input.consume();
+
+                    else:
+                        mse = MismatchedSetException(None, self.input)
+                        self.recover(mse)
+                        raise mse
+
+
+
+
+                else:
+                    break #loop1
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end IDENTIFIER
+
+
+
+    # $ANTLR start LETTER
+    def mLETTER(self, ):
+
+        try:
+            # C.g:539:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' )
+            # C.g:
+            if self.input.LA(1) == u'$' or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'):
+                self.input.consume();
+
+            else:
+                mse = MismatchedSetException(None, self.input)
+                self.recover(mse)
+                raise mse
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end LETTER
+
+
+
+    # $ANTLR start CHARACTER_LITERAL
+    def mCHARACTER_LITERAL(self, ):
+
+        try:
+            self.type = CHARACTER_LITERAL
+
+            # C.g:546:5: ( ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' )
+            # C.g:546:9: ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\''
+            # C.g:546:9: ( 'L' )?
+            alt2 = 2
+            LA2_0 = self.input.LA(1)
+
+            if (LA2_0 == u'L') :
+                alt2 = 1
+            if alt2 == 1:
+                # C.g:546:10: 'L'
+                self.match(u'L')
+
+
+
+
+            self.match(u'\'')
+
+            # C.g:546:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )
+            alt3 = 2
+            LA3_0 = self.input.LA(1)
+
+            if (LA3_0 == u'\\') :
+                alt3 = 1
+            elif ((u'\u0000' <= LA3_0 <= u'&') or (u'(' <= LA3_0 <= u'[') or (u']' <= LA3_0 <= u'\uFFFE')) :
+                alt3 = 2
+            else:
+                nvae = NoViableAltException("546:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )", 3, 0, self.input)
+
+                raise nvae
+
+            if alt3 == 1:
+                # C.g:546:23: EscapeSequence
+                self.mEscapeSequence()
+
+
+
+            elif alt3 == 2:
+                # C.g:546:40: ~ ( '\\'' | '\\\\' )
+                if (u'\u0000' <= self.input.LA(1) <= u'&') or (u'(' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+
+            self.match(u'\'')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end CHARACTER_LITERAL
+
+
+
+    # $ANTLR start STRING_LITERAL
+    def mSTRING_LITERAL(self, ):
+
+        try:
+            self.type = STRING_LITERAL
+
+            # C.g:550:5: ( ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' )
+            # C.g:550:8: ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"'
+            # C.g:550:8: ( 'L' )?
+            alt4 = 2
+            LA4_0 = self.input.LA(1)
+
+            if (LA4_0 == u'L') :
+                alt4 = 1
+            if alt4 == 1:
+                # C.g:550:9: 'L'
+                self.match(u'L')
+
+
+
+
+            self.match(u'"')
+
+            # C.g:550:19: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )*
+            while True: #loop5
+                alt5 = 3
+                LA5_0 = self.input.LA(1)
+
+                if (LA5_0 == u'\\') :
+                    alt5 = 1
+                elif ((u'\u0000' <= LA5_0 <= u'!') or (u'#' <= LA5_0 <= u'[') or (u']' <= LA5_0 <= u'\uFFFE')) :
+                    alt5 = 2
+
+
+                if alt5 == 1:
+                    # C.g:550:21: EscapeSequence
+                    self.mEscapeSequence()
+
+
+
+                elif alt5 == 2:
+                    # C.g:550:38: ~ ( '\\\\' | '\"' )
+                    if (u'\u0000' <= self.input.LA(1) <= u'!') or (u'#' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):
+                        self.input.consume();
+
+                    else:
+                        mse = MismatchedSetException(None, self.input)
+                        self.recover(mse)
+                        raise mse
+
+
+
+
+                else:
+                    break #loop5
+
+
+            self.match(u'"')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end STRING_LITERAL
+
+
+
+    # $ANTLR start HEX_LITERAL
+    def mHEX_LITERAL(self, ):
+
+        try:
+            self.type = HEX_LITERAL
+
+            # C.g:553:13: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? )
+            # C.g:553:15: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )?
+            self.match(u'0')
+
+            if self.input.LA(1) == u'X' or self.input.LA(1) == u'x':
+                self.input.consume();
+
+            else:
+                mse = MismatchedSetException(None, self.input)
+                self.recover(mse)
+                raise mse
+
+
+            # C.g:553:29: ( HexDigit )+
+            cnt6 = 0
+            while True: #loop6
+                alt6 = 2
+                LA6_0 = self.input.LA(1)
+
+                if ((u'0' <= LA6_0 <= u'9') or (u'A' <= LA6_0 <= u'F') or (u'a' <= LA6_0 <= u'f')) :
+                    alt6 = 1
+
+
+                if alt6 == 1:
+                    # C.g:553:29: HexDigit
+                    self.mHexDigit()
+
+
+
+                else:
+                    if cnt6 >= 1:
+                        break #loop6
+
+                    eee = EarlyExitException(6, self.input)
+                    raise eee
+
+                cnt6 += 1
+
+
+            # C.g:553:39: ( IntegerTypeSuffix )?
+            alt7 = 2
+            LA7_0 = self.input.LA(1)
+
+            if (LA7_0 == u'L' or LA7_0 == u'U' or LA7_0 == u'l' or LA7_0 == u'u') :
+                alt7 = 1
+            if alt7 == 1:
+                # C.g:553:39: IntegerTypeSuffix
+                self.mIntegerTypeSuffix()
+
+
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end HEX_LITERAL
+
+
+
+    # $ANTLR start DECIMAL_LITERAL
+    def mDECIMAL_LITERAL(self, ):
+
+        try:
+            self.type = DECIMAL_LITERAL
+
+            # C.g:555:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? )
+            # C.g:555:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )?
+            # C.g:555:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )
+            alt9 = 2
+            LA9_0 = self.input.LA(1)
+
+            if (LA9_0 == u'0') :
+                alt9 = 1
+            elif ((u'1' <= LA9_0 <= u'9')) :
+                alt9 = 2
+            else:
+                nvae = NoViableAltException("555:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )", 9, 0, self.input)
+
+                raise nvae
+
+            if alt9 == 1:
+                # C.g:555:20: '0'
+                self.match(u'0')
+
+
+
+            elif alt9 == 2:
+                # C.g:555:26: '1' .. '9' ( '0' .. '9' )*
+                self.matchRange(u'1', u'9')
+
+                # C.g:555:35: ( '0' .. '9' )*
+                while True: #loop8
+                    alt8 = 2
+                    LA8_0 = self.input.LA(1)
+
+                    if ((u'0' <= LA8_0 <= u'9')) :
+                        alt8 = 1
+
+
+                    if alt8 == 1:
+                        # C.g:555:35: '0' .. '9'
+                        self.matchRange(u'0', u'9')
+
+
+
+                    else:
+                        break #loop8
+
+
+
+
+
+            # C.g:555:46: ( IntegerTypeSuffix )?
+            alt10 = 2
+            LA10_0 = self.input.LA(1)
+
+            if (LA10_0 == u'L' or LA10_0 == u'U' or LA10_0 == u'l' or LA10_0 == u'u') :
+                alt10 = 1
+            if alt10 == 1:
+                # C.g:555:46: IntegerTypeSuffix
+                self.mIntegerTypeSuffix()
+
+
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end DECIMAL_LITERAL
+
+
+
+    # $ANTLR start OCTAL_LITERAL
+    def mOCTAL_LITERAL(self, ):
+
+        try:
+            self.type = OCTAL_LITERAL
+
+            # C.g:557:15: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? )
+            # C.g:557:17: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )?
+            self.match(u'0')
+
+            # C.g:557:21: ( '0' .. '7' )+
+            cnt11 = 0
+            while True: #loop11
+                alt11 = 2
+                LA11_0 = self.input.LA(1)
+
+                if ((u'0' <= LA11_0 <= u'7')) :
+                    alt11 = 1
+
+
+                if alt11 == 1:
+                    # C.g:557:22: '0' .. '7'
+                    self.matchRange(u'0', u'7')
+
+
+
+                else:
+                    if cnt11 >= 1:
+                        break #loop11
+
+                    eee = EarlyExitException(11, self.input)
+                    raise eee
+
+                cnt11 += 1
+
+
+            # C.g:557:33: ( IntegerTypeSuffix )?
+            alt12 = 2
+            LA12_0 = self.input.LA(1)
+
+            if (LA12_0 == u'L' or LA12_0 == u'U' or LA12_0 == u'l' or LA12_0 == u'u') :
+                alt12 = 1
+            if alt12 == 1:
+                # C.g:557:33: IntegerTypeSuffix
+                self.mIntegerTypeSuffix()
+
+
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end OCTAL_LITERAL
+
+
+
+    # $ANTLR start HexDigit
+    def mHexDigit(self, ):
+
+        try:
+            # C.g:560:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
+            # C.g:560:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
+            if (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'F') or (u'a' <= self.input.LA(1) <= u'f'):
+                self.input.consume();
+
+            else:
+                mse = MismatchedSetException(None, self.input)
+                self.recover(mse)
+                raise mse
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end HexDigit
+
+
+
+    # $ANTLR start IntegerTypeSuffix
+    def mIntegerTypeSuffix(self, ):
+
+        try:
+            # C.g:564:2: ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) )
+            alt13 = 4
+            LA13_0 = self.input.LA(1)
+
+            if (LA13_0 == u'U' or LA13_0 == u'u') :
+                LA13_1 = self.input.LA(2)
+
+                if (LA13_1 == u'L' or LA13_1 == u'l') :
+                    LA13_3 = self.input.LA(3)
+
+                    if (LA13_3 == u'L' or LA13_3 == u'l') :
+                        alt13 = 4
+                    else:
+                        alt13 = 3
+                else:
+                    alt13 = 1
+            elif (LA13_0 == u'L' or LA13_0 == u'l') :
+                alt13 = 2
+            else:
+                nvae = NoViableAltException("562:1: fragment IntegerTypeSuffix : ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) );", 13, 0, self.input)
+
+                raise nvae
+
+            if alt13 == 1:
+                # C.g:564:4: ( 'u' | 'U' )
+                if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+            elif alt13 == 2:
+                # C.g:565:4: ( 'l' | 'L' )
+                if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+            elif alt13 == 3:
+                # C.g:566:4: ( 'u' | 'U' ) ( 'l' | 'L' )
+                if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+                if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+            elif alt13 == 4:
+                # C.g:567:4: ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' )
+                if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+                if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+                if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end IntegerTypeSuffix
+
+
+
+    # $ANTLR start FLOATING_POINT_LITERAL
+    def mFLOATING_POINT_LITERAL(self, ):
+
+        try:
+            self.type = FLOATING_POINT_LITERAL
+
+            # C.g:571:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix )
+            alt25 = 4
+            alt25 = self.dfa25.predict(self.input)
+            if alt25 == 1:
+                # C.g:571:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )?
+                # C.g:571:9: ( '0' .. '9' )+
+                cnt14 = 0
+                while True: #loop14
+                    alt14 = 2
+                    LA14_0 = self.input.LA(1)
+
+                    if ((u'0' <= LA14_0 <= u'9')) :
+                        alt14 = 1
+
+
+                    if alt14 == 1:
+                        # C.g:571:10: '0' .. '9'
+                        self.matchRange(u'0', u'9')
+
+
+
+                    else:
+                        if cnt14 >= 1:
+                            break #loop14
+
+                        eee = EarlyExitException(14, self.input)
+                        raise eee
+
+                    cnt14 += 1
+
+
+                self.match(u'.')
+
+                # C.g:571:25: ( '0' .. '9' )*
+                while True: #loop15
+                    alt15 = 2
+                    LA15_0 = self.input.LA(1)
+
+                    if ((u'0' <= LA15_0 <= u'9')) :
+                        alt15 = 1
+
+
+                    if alt15 == 1:
+                        # C.g:571:26: '0' .. '9'
+                        self.matchRange(u'0', u'9')
+
+
+
+                    else:
+                        break #loop15
+
+
+                # C.g:571:37: ( Exponent )?
+                alt16 = 2
+                LA16_0 = self.input.LA(1)
+
+                if (LA16_0 == u'E' or LA16_0 == u'e') :
+                    alt16 = 1
+                if alt16 == 1:
+                    # C.g:571:37: Exponent
+                    self.mExponent()
+
+
+
+
+                # C.g:571:47: ( FloatTypeSuffix )?
+                alt17 = 2
+                LA17_0 = self.input.LA(1)
+
+                if (LA17_0 == u'D' or LA17_0 == u'F' or LA17_0 == u'd' or LA17_0 == u'f') :
+                    alt17 = 1
+                if alt17 == 1:
+                    # C.g:571:47: FloatTypeSuffix
+                    self.mFloatTypeSuffix()
+
+
+
+
+
+
+            elif alt25 == 2:
+                # C.g:572:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )?
+                self.match(u'.')
+
+                # C.g:572:13: ( '0' .. '9' )+
+                cnt18 = 0
+                while True: #loop18
+                    alt18 = 2
+                    LA18_0 = self.input.LA(1)
+
+                    if ((u'0' <= LA18_0 <= u'9')) :
+                        alt18 = 1
+
+
+                    if alt18 == 1:
+                        # C.g:572:14: '0' .. '9'
+                        self.matchRange(u'0', u'9')
+
+
+
+                    else:
+                        if cnt18 >= 1:
+                            break #loop18
+
+                        eee = EarlyExitException(18, self.input)
+                        raise eee
+
+                    cnt18 += 1
+
+
+                # C.g:572:25: ( Exponent )?
+                alt19 = 2
+                LA19_0 = self.input.LA(1)
+
+                if (LA19_0 == u'E' or LA19_0 == u'e') :
+                    alt19 = 1
+                if alt19 == 1:
+                    # C.g:572:25: Exponent
+                    self.mExponent()
+
+
+
+
+                # C.g:572:35: ( FloatTypeSuffix )?
+                alt20 = 2
+                LA20_0 = self.input.LA(1)
+
+                if (LA20_0 == u'D' or LA20_0 == u'F' or LA20_0 == u'd' or LA20_0 == u'f') :
+                    alt20 = 1
+                if alt20 == 1:
+                    # C.g:572:35: FloatTypeSuffix
+                    self.mFloatTypeSuffix()
+
+
+
+
+
+
+            elif alt25 == 3:
+                # C.g:573:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )?
+                # C.g:573:9: ( '0' .. '9' )+
+                cnt21 = 0
+                while True: #loop21
+                    alt21 = 2
+                    LA21_0 = self.input.LA(1)
+
+                    if ((u'0' <= LA21_0 <= u'9')) :
+                        alt21 = 1
+
+
+                    if alt21 == 1:
+                        # C.g:573:10: '0' .. '9'
+                        self.matchRange(u'0', u'9')
+
+
+
+                    else:
+                        if cnt21 >= 1:
+                            break #loop21
+
+                        eee = EarlyExitException(21, self.input)
+                        raise eee
+
+                    cnt21 += 1
+
+
+                self.mExponent()
+
+                # C.g:573:30: ( FloatTypeSuffix )?
+                alt22 = 2
+                LA22_0 = self.input.LA(1)
+
+                if (LA22_0 == u'D' or LA22_0 == u'F' or LA22_0 == u'd' or LA22_0 == u'f') :
+                    alt22 = 1
+                if alt22 == 1:
+                    # C.g:573:30: FloatTypeSuffix
+                    self.mFloatTypeSuffix()
+
+
+
+
+
+
+            elif alt25 == 4:
+                # C.g:574:9: ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix
+                # C.g:574:9: ( '0' .. '9' )+
+                cnt23 = 0
+                while True: #loop23
+                    alt23 = 2
+                    LA23_0 = self.input.LA(1)
+
+                    if ((u'0' <= LA23_0 <= u'9')) :
+                        alt23 = 1
+
+
+                    if alt23 == 1:
+                        # C.g:574:10: '0' .. '9'
+                        self.matchRange(u'0', u'9')
+
+
+
+                    else:
+                        if cnt23 >= 1:
+                            break #loop23
+
+                        eee = EarlyExitException(23, self.input)
+                        raise eee
+
+                    cnt23 += 1
+
+
+                # C.g:574:21: ( Exponent )?
+                alt24 = 2
+                LA24_0 = self.input.LA(1)
+
+                if (LA24_0 == u'E' or LA24_0 == u'e') :
+                    alt24 = 1
+                if alt24 == 1:
+                    # C.g:574:21: Exponent
+                    self.mExponent()
+
+
+
+
+                self.mFloatTypeSuffix()
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end FLOATING_POINT_LITERAL
+
+
+
+    # $ANTLR start Exponent
+    def mExponent(self, ):
+
+        try:
+            # C.g:578:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
+            # C.g:578:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
+            if self.input.LA(1) == u'E' or self.input.LA(1) == u'e':
+                self.input.consume();
+
+            else:
+                mse = MismatchedSetException(None, self.input)
+                self.recover(mse)
+                raise mse
+
+
+            # C.g:578:22: ( '+' | '-' )?
+            alt26 = 2
+            LA26_0 = self.input.LA(1)
+
+            if (LA26_0 == u'+' or LA26_0 == u'-') :
+                alt26 = 1
+            if alt26 == 1:
+                # C.g:
+                if self.input.LA(1) == u'+' or self.input.LA(1) == u'-':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+
+            # C.g:578:33: ( '0' .. '9' )+
+            cnt27 = 0
+            while True: #loop27
+                alt27 = 2
+                LA27_0 = self.input.LA(1)
+
+                if ((u'0' <= LA27_0 <= u'9')) :
+                    alt27 = 1
+
+
+                if alt27 == 1:
+                    # C.g:578:34: '0' .. '9'
+                    self.matchRange(u'0', u'9')
+
+
+
+                else:
+                    if cnt27 >= 1:
+                        break #loop27
+
+                    eee = EarlyExitException(27, self.input)
+                    raise eee
+
+                cnt27 += 1
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end Exponent
+
+
+
+    # $ANTLR start FloatTypeSuffix
+    def mFloatTypeSuffix(self, ):
+
+        try:
+            # C.g:581:17: ( ( 'f' | 'F' | 'd' | 'D' ) )
+            # C.g:581:19: ( 'f' | 'F' | 'd' | 'D' )
+            if self.input.LA(1) == u'D' or self.input.LA(1) == u'F' or self.input.LA(1) == u'd' or self.input.LA(1) == u'f':
+                self.input.consume();
+
+            else:
+                mse = MismatchedSetException(None, self.input)
+                self.recover(mse)
+                raise mse
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end FloatTypeSuffix
+
+
+
+    # $ANTLR start EscapeSequence
+    def mEscapeSequence(self, ):
+
+        try:
+            # C.g:585:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape )
+            alt28 = 2
+            LA28_0 = self.input.LA(1)
+
+            if (LA28_0 == u'\\') :
+                LA28_1 = self.input.LA(2)
+
+                if (LA28_1 == u'"' or LA28_1 == u'\'' or LA28_1 == u'\\' or LA28_1 == u'b' or LA28_1 == u'f' or LA28_1 == u'n' or LA28_1 == u'r' or LA28_1 == u't') :
+                    alt28 = 1
+                elif ((u'0' <= LA28_1 <= u'7')) :
+                    alt28 = 2
+                else:
+                    nvae = NoViableAltException("583:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 1, self.input)
+
+                    raise nvae
+
+            else:
+                nvae = NoViableAltException("583:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 0, self.input)
+
+                raise nvae
+
+            if alt28 == 1:
+                # C.g:585:8: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
+                self.match(u'\\')
+
+                if self.input.LA(1) == u'"' or self.input.LA(1) == u'\'' or self.input.LA(1) == u'\\' or self.input.LA(1) == u'b' or self.input.LA(1) == u'f' or self.input.LA(1) == u'n' or self.input.LA(1) == u'r' or self.input.LA(1) == u't':
+                    self.input.consume();
+
+                else:
+                    mse = MismatchedSetException(None, self.input)
+                    self.recover(mse)
+                    raise mse
+
+
+
+
+            elif alt28 == 2:
+                # C.g:586:9: OctalEscape
+                self.mOctalEscape()
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end EscapeSequence
+
+
+
+    # $ANTLR start OctalEscape
+    def mOctalEscape(self, ):
+
+        try:
+            # C.g:591:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
+            alt29 = 3
+            LA29_0 = self.input.LA(1)
+
+            if (LA29_0 == u'\\') :
+                LA29_1 = self.input.LA(2)
+
+                if ((u'0' <= LA29_1 <= u'3')) :
+                    LA29_2 = self.input.LA(3)
+
+                    if ((u'0' <= LA29_2 <= u'7')) :
+                        LA29_5 = self.input.LA(4)
+
+                        if ((u'0' <= LA29_5 <= u'7')) :
+                            alt29 = 1
+                        else:
+                            alt29 = 2
+                    else:
+                        alt29 = 3
+                elif ((u'4' <= LA29_1 <= u'7')) :
+                    LA29_3 = self.input.LA(3)
+
+                    if ((u'0' <= LA29_3 <= u'7')) :
+                        alt29 = 2
+                    else:
+                        alt29 = 3
+                else:
+                    nvae = NoViableAltException("589:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 1, self.input)
+
+                    raise nvae
+
+            else:
+                nvae = NoViableAltException("589:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 0, self.input)
+
+                raise nvae
+
+            if alt29 == 1:
+                # C.g:591:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
+                self.match(u'\\')
+
+                # C.g:591:14: ( '0' .. '3' )
+                # C.g:591:15: '0' .. '3'
+                self.matchRange(u'0', u'3')
+
+
+
+
+                # C.g:591:25: ( '0' .. '7' )
+                # C.g:591:26: '0' .. '7'
+                self.matchRange(u'0', u'7')
+
+
+
+
+                # C.g:591:36: ( '0' .. '7' )
+                # C.g:591:37: '0' .. '7'
+                self.matchRange(u'0', u'7')
+
+
+
+
+
+
+            elif alt29 == 2:
+                # C.g:592:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
+                self.match(u'\\')
+
+                # C.g:592:14: ( '0' .. '7' )
+                # C.g:592:15: '0' .. '7'
+                self.matchRange(u'0', u'7')
+
+
+
+
+                # C.g:592:25: ( '0' .. '7' )
+                # C.g:592:26: '0' .. '7'
+                self.matchRange(u'0', u'7')
+
+
+
+
+
+
+            elif alt29 == 3:
+                # C.g:593:9: '\\\\' ( '0' .. '7' )
+                self.match(u'\\')
+
+                # C.g:593:14: ( '0' .. '7' )
+                # C.g:593:15: '0' .. '7'
+                self.matchRange(u'0', u'7')
+
+
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end OctalEscape
+
+
+
+    # $ANTLR start UnicodeEscape
+    def mUnicodeEscape(self, ):
+
+        try:
+            # C.g:598:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )
+            # C.g:598:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit
+            self.match(u'\\')
+
+            self.match(u'u')
+
+            self.mHexDigit()
+
+            self.mHexDigit()
+
+            self.mHexDigit()
+
+            self.mHexDigit()
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end UnicodeEscape
+
+
+
+    # $ANTLR start WS
+    def mWS(self, ):
+
+        try:
+            self.type = WS
+
+            # C.g:601:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
+            # C.g:601:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
+            if (u'\t' <= self.input.LA(1) <= u'\n') or (u'\f' <= self.input.LA(1) <= u'\r') or self.input.LA(1) == u' ':
+                self.input.consume();
+
+            else:
+                mse = MismatchedSetException(None, self.input)
+                self.recover(mse)
+                raise mse
+
+
+            #action start
+            self.channel=HIDDEN;
+            #action end
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end WS
+
+
+
+    # $ANTLR start BS
+    def mBS(self, ):
+
+        try:
+            self.type = BS
+
+            # C.g:605:5: ( ( '\\\\' ) )
+            # C.g:605:7: ( '\\\\' )
+            # C.g:605:7: ( '\\\\' )
+            # C.g:605:8: '\\\\'
+            self.match(u'\\')
+
+
+
+
+            #action start
+            self.channel=HIDDEN;
+            #action end
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end BS
+
+
+
+    # $ANTLR start UnicodeVocabulary
+    def mUnicodeVocabulary(self, ):
+
+        try:
+            self.type = UnicodeVocabulary
+
+            # C.g:613:5: ( '\\u0003' .. '\\uFFFE' )
+            # C.g:613:7: '\\u0003' .. '\\uFFFE'
+            self.matchRange(u'\u0003', u'\uFFFE')
+
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end UnicodeVocabulary
+
+
+
+    # $ANTLR start COMMENT
+    def mCOMMENT(self, ):
+
+        try:
+            self.type = COMMENT
+
+            # C.g:616:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            # C.g:616:9: '/*' ( options {greedy=false; } : . )* '*/'
+            self.match("/*")
+
+
+            # C.g:616:14: ( options {greedy=false; } : . )*
+            while True: #loop30
+                alt30 = 2
+                LA30_0 = self.input.LA(1)
+
+                if (LA30_0 == u'*') :
+                    LA30_1 = self.input.LA(2)
+
+                    if (LA30_1 == u'/') :
+                        alt30 = 2
+                    elif ((u'\u0000' <= LA30_1 <= u'.') or (u'0' <= LA30_1 <= u'\uFFFE')) :
+                        alt30 = 1
+
+
+                elif ((u'\u0000' <= LA30_0 <= u')') or (u'+' <= LA30_0 <= u'\uFFFE')) :
+                    alt30 = 1
+
+
+                if alt30 == 1:
+                    # C.g:616:42: .
+                    self.matchAny()
+
+
+
+                else:
+                    break #loop30
+
+
+            self.match("*/")
+
+
+            #action start
+            self.channel=HIDDEN;
+            #action end
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end COMMENT
+
+
+
+    # $ANTLR start LINE_COMMENT
+    def mLINE_COMMENT(self, ):
+
+        try:
+            self.type = LINE_COMMENT
+
+            # C.g:621:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
+            # C.g:621:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
+            self.match("//")
+
+
+            # C.g:621:12: (~ ( '\\n' | '\\r' ) )*
+            while True: #loop31
+                alt31 = 2
+                LA31_0 = self.input.LA(1)
+
+                if ((u'\u0000' <= LA31_0 <= u'\t') or (u'\u000B' <= LA31_0 <= u'\f') or (u'\u000E' <= LA31_0 <= u'\uFFFE')) :
+                    alt31 = 1
+
+
+                if alt31 == 1:
+                    # C.g:621:12: ~ ( '\\n' | '\\r' )
+                    if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'):
+                        self.input.consume();
+
+                    else:
+                        mse = MismatchedSetException(None, self.input)
+                        self.recover(mse)
+                        raise mse
+
+
+
+
+                else:
+                    break #loop31
+
+
+            # C.g:621:26: ( '\\r' )?
+            alt32 = 2
+            LA32_0 = self.input.LA(1)
+
+            if (LA32_0 == u'\r') :
+                alt32 = 1
+            if alt32 == 1:
+                # C.g:621:26: '\\r'
+                self.match(u'\r')
+
+
+
+
+            self.match(u'\n')
+
+            #action start
+            self.channel=HIDDEN;
+            #action end
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end LINE_COMMENT
+
+
+
+    # $ANTLR start LINE_COMMAND
+    def mLINE_COMMAND(self, ):
+
+        try:
+            self.type = LINE_COMMAND
+
+            # C.g:626:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
+            # C.g:626:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
+            self.match(u'#')
+
+            # C.g:626:11: (~ ( '\\n' | '\\r' ) )*
+            while True: #loop33
+                alt33 = 2
+                LA33_0 = self.input.LA(1)
+
+                if ((u'\u0000' <= LA33_0 <= u'\t') or (u'\u000B' <= LA33_0 <= u'\f') or (u'\u000E' <= LA33_0 <= u'\uFFFE')) :
+                    alt33 = 1
+
+
+                if alt33 == 1:
+                    # C.g:626:11: ~ ( '\\n' | '\\r' )
+                    if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'):
+                        self.input.consume();
+
+                    else:
+                        mse = MismatchedSetException(None, self.input)
+                        self.recover(mse)
+                        raise mse
+
+
+
+
+                else:
+                    break #loop33
+
+
+            # C.g:626:25: ( '\\r' )?
+            alt34 = 2
+            LA34_0 = self.input.LA(1)
+
+            if (LA34_0 == u'\r') :
+                alt34 = 1
+            if alt34 == 1:
+                # C.g:626:25: '\\r'
+                self.match(u'\r')
+
+
+
+
+            self.match(u'\n')
+
+            #action start
+            self.channel=HIDDEN;
+            #action end
+
+
+
+
+        finally:
+
+            pass
+
+    # $ANTLR end LINE_COMMAND
+
+
+
+    def mTokens(self):
+        # C.g:1:8: ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | T34 | T35 | T36 | T37 | T38 | T39 | T40 | T41 | T42 | T43 | T44 | T45 | T46 | T47 | T48 | T49 | T50 | T51 | T52 | T53 | T54 | T55 | T56 | T57 | T58 | T59 | T60 | T61 | T62 | T63 | T64 | T65 | T66 | T67 | T68 | T69 | T70 | T71 | T72 | T73 | T74 | T75 | T76 | T77 | T78 | T79 | T80 | T81 | T82 | T83 | T84 | T85 | T86 | T87 | T88 | T89 | T90 | T91 | T92 | T93 | T94 | T95 | T96 | T97 | T98 | T99 | T100 | T101 | T102 | T103 | T104 | T105 | T106 | T107 | T108 | T109 | T110 | T111 | T112 | T113 | T114 | T115 | IDENTIFIER | CHARACTER_LITERAL | STRING_LITERAL | HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOATING_POINT_LITERAL | WS | BS | UnicodeVocabulary | COMMENT | LINE_COMMENT | LINE_COMMAND )
+        alt35 = 104
+        alt35 = self.dfa35.predict(self.input)
+        if alt35 == 1:
+            # C.g:1:10: T25
+            self.mT25()
+
+
+
+        elif alt35 == 2:
+            # C.g:1:14: T26
+            self.mT26()
+
+
+
+        elif alt35 == 3:
+            # C.g:1:18: T27
+            self.mT27()
+
+
+
+        elif alt35 == 4:
+            # C.g:1:22: T28
+            self.mT28()
+
+
+
+        elif alt35 == 5:
+            # C.g:1:26: T29
+            self.mT29()
+
+
+
+        elif alt35 == 6:
+            # C.g:1:30: T30
+            self.mT30()
+
+
+
+        elif alt35 == 7:
+            # C.g:1:34: T31
+            self.mT31()
+
+
+
+        elif alt35 == 8:
+            # C.g:1:38: T32
+            self.mT32()
+
+
+
+        elif alt35 == 9:
+            # C.g:1:42: T33
+            self.mT33()
+
+
+
+        elif alt35 == 10:
+            # C.g:1:46: T34
+            self.mT34()
+
+
+
+        elif alt35 == 11:
+            # C.g:1:50: T35
+            self.mT35()
+
+
+
+        elif alt35 == 12:
+            # C.g:1:54: T36
+            self.mT36()
+
+
+
+        elif alt35 == 13:
+            # C.g:1:58: T37
+            self.mT37()
+
+
+
+        elif alt35 == 14:
+            # C.g:1:62: T38
+            self.mT38()
+
+
+
+        elif alt35 == 15:
+            # C.g:1:66: T39
+            self.mT39()
+
+
+
+        elif alt35 == 16:
+            # C.g:1:70: T40
+            self.mT40()
+
+
+
+        elif alt35 == 17:
+            # C.g:1:74: T41
+            self.mT41()
+
+
+
+        elif alt35 == 18:
+            # C.g:1:78: T42
+            self.mT42()
+
+
+
+        elif alt35 == 19:
+            # C.g:1:82: T43
+            self.mT43()
+
+
+
+        elif alt35 == 20:
+            # C.g:1:86: T44
+            self.mT44()
+
+
+
+        elif alt35 == 21:
+            # C.g:1:90: T45
+            self.mT45()
+
+
+
+        elif alt35 == 22:
+            # C.g:1:94: T46
+            self.mT46()
+
+
+
+        elif alt35 == 23:
+            # C.g:1:98: T47
+            self.mT47()
+
+
+
+        elif alt35 == 24:
+            # C.g:1:102: T48
+            self.mT48()
+
+
+
+        elif alt35 == 25:
+            # C.g:1:106: T49
+            self.mT49()
+
+
+
+        elif alt35 == 26:
+            # C.g:1:110: T50
+            self.mT50()
+
+
+
+        elif alt35 == 27:
+            # C.g:1:114: T51
+            self.mT51()
+
+
+
+        elif alt35 == 28:
+            # C.g:1:118: T52
+            self.mT52()
+
+
+
+        elif alt35 == 29:
+            # C.g:1:122: T53
+            self.mT53()
+
+
+
+        elif alt35 == 30:
+            # C.g:1:126: T54
+            self.mT54()
+
+
+
+        elif alt35 == 31:
+            # C.g:1:130: T55
+            self.mT55()
+
+
+
+        elif alt35 == 32:
+            # C.g:1:134: T56
+            self.mT56()
+
+
+
+        elif alt35 == 33:
+            # C.g:1:138: T57
+            self.mT57()
+
+
+
+        elif alt35 == 34:
+            # C.g:1:142: T58
+            self.mT58()
+
+
+
+        elif alt35 == 35:
+            # C.g:1:146: T59
+            self.mT59()
+
+
+
+        elif alt35 == 36:
+            # C.g:1:150: T60
+            self.mT60()
+
+
+
+        elif alt35 == 37:
+            # C.g:1:154: T61
+            self.mT61()
+
+
+
+        elif alt35 == 38:
+            # C.g:1:158: T62
+            self.mT62()
+
+
+
+        elif alt35 == 39:
+            # C.g:1:162: T63
+            self.mT63()
+
+
+
+        elif alt35 == 40:
+            # C.g:1:166: T64
+            self.mT64()
+
+
+
+        elif alt35 == 41:
+            # C.g:1:170: T65
+            self.mT65()
+
+
+
+        elif alt35 == 42:
+            # C.g:1:174: T66
+            self.mT66()
+
+
+
+        elif alt35 == 43:
+            # C.g:1:178: T67
+            self.mT67()
+
+
+
+        elif alt35 == 44:
+            # C.g:1:182: T68
+            self.mT68()
+
+
+
+        elif alt35 == 45:
+            # C.g:1:186: T69
+            self.mT69()
+
+
+
+        elif alt35 == 46:
+            # C.g:1:190: T70
+            self.mT70()
+
+
+
+        elif alt35 == 47:
+            # C.g:1:194: T71
+            self.mT71()
+
+
+
+        elif alt35 == 48:
+            # C.g:1:198: T72
+            self.mT72()
+
+
+
+        elif alt35 == 49:
+            # C.g:1:202: T73
+            self.mT73()
+
+
+
+        elif alt35 == 50:
+            # C.g:1:206: T74
+            self.mT74()
+
+
+
+        elif alt35 == 51:
+            # C.g:1:210: T75
+            self.mT75()
+
+
+
+        elif alt35 == 52:
+            # C.g:1:214: T76
+            self.mT76()
+
+
+
+        elif alt35 == 53:
+            # C.g:1:218: T77
+            self.mT77()
+
+
+
+        elif alt35 == 54:
+            # C.g:1:222: T78
+            self.mT78()
+
+
+
+        elif alt35 == 55:
+            # C.g:1:226: T79
+            self.mT79()
+
+
+
+        elif alt35 == 56:
+            # C.g:1:230: T80
+            self.mT80()
+
+
+
+        elif alt35 == 57:
+            # C.g:1:234: T81
+            self.mT81()
+
+
+
+        elif alt35 == 58:
+            # C.g:1:238: T82
+            self.mT82()
+
+
+
+        elif alt35 == 59:
+            # C.g:1:242: T83
+            self.mT83()
+
+
+
+        elif alt35 == 60:
+            # C.g:1:246: T84
+            self.mT84()
+
+
+
+        elif alt35 == 61:
+            # C.g:1:250: T85
+            self.mT85()
+
+
+
+        elif alt35 == 62:
+            # C.g:1:254: T86
+            self.mT86()
+
+
+
+        elif alt35 == 63:
+            # C.g:1:258: T87
+            self.mT87()
+
+
+
+        elif alt35 == 64:
+            # C.g:1:262: T88
+            self.mT88()
+
+
+
+        elif alt35 == 65:
+            # C.g:1:266: T89
+            self.mT89()
+
+
+
+        elif alt35 == 66:
+            # C.g:1:270: T90
+            self.mT90()
+
+
+
+        elif alt35 == 67:
+            # C.g:1:274: T91
+            self.mT91()
+
+
+
+        elif alt35 == 68:
+            # C.g:1:278: T92
+            self.mT92()
+
+
+
+        elif alt35 == 69:
+            # C.g:1:282: T93
+            self.mT93()
+
+
+
+        elif alt35 == 70:
+            # C.g:1:286: T94
+            self.mT94()
+
+
+
+        elif alt35 == 71:
+            # C.g:1:290: T95
+            self.mT95()
+
+
+
+        elif alt35 == 72:
+            # C.g:1:294: T96
+            self.mT96()
+
+
+
+        elif alt35 == 73:
+            # C.g:1:298: T97
+            self.mT97()
+
+
+
+        elif alt35 == 74:
+            # C.g:1:302: T98
+            self.mT98()
+
+
+
+        elif alt35 == 75:
+            # C.g:1:306: T99
+            self.mT99()
+
+
+
+        elif alt35 == 76:
+            # C.g:1:310: T100
+            self.mT100()
+
+
+
+        elif alt35 == 77:
+            # C.g:1:315: T101
+            self.mT101()
+
+
+
+        elif alt35 == 78:
+            # C.g:1:320: T102
+            self.mT102()
+
+
+
+        elif alt35 == 79:
+            # C.g:1:325: T103
+            self.mT103()
+
+
+
+        elif alt35 == 80:
+            # C.g:1:330: T104
+            self.mT104()
+
+
+
+        elif alt35 == 81:
+            # C.g:1:335: T105
+            self.mT105()
+
+
+
+        elif alt35 == 82:
+            # C.g:1:340: T106
+            self.mT106()
+
+
+
+        elif alt35 == 83:
+            # C.g:1:345: T107
+            self.mT107()
+
+
+
+        elif alt35 == 84:
+            # C.g:1:350: T108
+            self.mT108()
+
+
+
+        elif alt35 == 85:
+            # C.g:1:355: T109
+            self.mT109()
+
+
+
+        elif alt35 == 86:
+            # C.g:1:360: T110
+            self.mT110()
+
+
+
+        elif alt35 == 87:
+            # C.g:1:365: T111
+            self.mT111()
+
+
+
+        elif alt35 == 88:
+            # C.g:1:370: T112
+            self.mT112()
+
+
+
+        elif alt35 == 89:
+            # C.g:1:375: T113
+            self.mT113()
+
+
+
+        elif alt35 == 90:
+            # C.g:1:380: T114
+            self.mT114()
+
+
+
+        elif alt35 == 91:
+            # C.g:1:385: T115
+            self.mT115()
+
+
+
+        elif alt35 == 92:
+            # C.g:1:390: IDENTIFIER
+            self.mIDENTIFIER()
+
+
+
+        elif alt35 == 93:
+            # C.g:1:401: CHARACTER_LITERAL
+            self.mCHARACTER_LITERAL()
+
+
+
+        elif alt35 == 94:
+            # C.g:1:419: STRING_LITERAL
+            self.mSTRING_LITERAL()
+
+
+
+        elif alt35 == 95:
+            # C.g:1:434: HEX_LITERAL
+            self.mHEX_LITERAL()
+
+
+
+        elif alt35 == 96:
+            # C.g:1:446: DECIMAL_LITERAL
+            self.mDECIMAL_LITERAL()
+
+
+
+        elif alt35 == 97:
+            # C.g:1:462: OCTAL_LITERAL
+            self.mOCTAL_LITERAL()
+
+
+
+        elif alt35 == 98:
+            # C.g:1:476: FLOATING_POINT_LITERAL
+            self.mFLOATING_POINT_LITERAL()
+
+
+
+        elif alt35 == 99:
+            # C.g:1:499: WS
+            self.mWS()
+
+
+
+        elif alt35 == 100:
+            # C.g:1:502: BS
+            self.mBS()
+
+
+
+        elif alt35 == 101:
+            # C.g:1:505: UnicodeVocabulary
+            self.mUnicodeVocabulary()
+
+
+
+        elif alt35 == 102:
+            # C.g:1:523: COMMENT
+            self.mCOMMENT()
+
+
+
+        elif alt35 == 103:
+            # C.g:1:531: LINE_COMMENT
+            self.mLINE_COMMENT()
+
+
+
+        elif alt35 == 104:
+            # C.g:1:544: LINE_COMMAND
+            self.mLINE_COMMAND()
+
+
+
+
+
+
+
+
+    # lookup tables for DFA #25
+
+    DFA25_eot = DFA.unpack(
+        u"\7\uffff\1\10\2\uffff"
+        )
+
+    DFA25_eof = DFA.unpack(
+        u"\12\uffff"
+        )
+
+    DFA25_min = DFA.unpack(
+        u"\2\56\1\uffff\1\53\2\uffff\2\60\2\uffff"
+        )
+
+    DFA25_max = DFA.unpack(
+        u"\1\71\1\146\1\uffff\1\71\2\uffff\1\71\1\146\2\uffff"
+        )
+
+    DFA25_accept = DFA.unpack(
+        u"\2\uffff\1\2\1\uffff\1\4\1\1\2\uffff\2\3"
+        )
+
+    DFA25_special = DFA.unpack(
+        u"\12\uffff"
+        )
+
+
+    DFA25_transition = [
+        DFA.unpack(u"\1\2\1\uffff\12\1"),
+        DFA.unpack(u"\1\5\1\uffff\12\1\12\uffff\1\4\1\3\1\4\35\uffff\1\4"
+        u"\1\3\1\4"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\6\1\uffff\1\6\2\uffff\12\7"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\12\7"),
+        DFA.unpack(u"\12\7\12\uffff\1\11\1\uffff\1\11\35\uffff\1\11\1\uffff"
+        u"\1\11"),
+        DFA.unpack(u""),
+        DFA.unpack(u"")
+    ]
+
+    # class definition for DFA #25
+
+    DFA25 = DFA
+    # lookup tables for DFA #35
+
+    DFA35_eot = DFA.unpack(
+        u"\2\uffff\1\75\1\uffff\1\100\14\75\3\uffff\7\75\4\uffff\1\147\1"
+        u"\152\1\155\1\161\1\165\1\167\1\172\1\uffff\1\175\1\u0080\1\u0083"
+        u"\1\u0085\1\u0088\1\uffff\5\75\1\uffff\2\72\2\u0093\2\uffff\1\72"
+        u"\2\uffff\1\75\4\uffff\17\75\1\u00ac\3\75\1\u00b1\2\75\3\uffff\1"
+        u"\u00b5\7\75\34\uffff\1\u00be\2\uffff\1\u00c0\10\uffff\5\75\3\uffff"
+        u"\1\u00c6\1\uffff\1\u0093\3\uffff\23\75\1\u00db\1\uffff\1\75\1\u00dd"
+        u"\2\75\1\uffff\3\75\1\uffff\1\75\1\u00e4\5\75\4\uffff\5\75\1\uffff"
+        u"\2\75\1\u00f2\1\u00f3\6\75\1\u00fa\4\75\1\u00ff\2\75\1\u0102\1"
+        u"\u0103\1\uffff\1\u0104\1\uffff\6\75\1\uffff\7\75\1\u0113\1\75\1"
+        u"\u0115\3\75\2\uffff\2\75\1\u011b\3\75\1\uffff\4\75\1\uffff\1\75"
+        u"\1\u0124\3\uffff\1\u0125\3\75\1\u0129\1\75\1\u012b\6\75\1\u0132"
+        u"\1\uffff\1\u0133\1\uffff\1\u0134\1\75\1\u0136\1\u0137\1\u0138\1"
+        u"\uffff\1\u0139\1\u013a\1\u013b\1\75\1\u013d\1\u013e\2\75\2\uffff"
+        u"\1\u0141\2\75\1\uffff\1\75\1\uffff\5\75\1\u014a\3\uffff\1\u014b"
+        u"\6\uffff\1\75\2\uffff\2\75\1\uffff\1\u014f\7\75\2\uffff\1\u0157"
+        u"\1\u0158\1\u0159\1\uffff\1\u015a\1\u015b\1\75\1\u015d\3\75\5\uffff"
+        u"\1\u0161\1\uffff\3\75\1\uffff\21\75\1\u0176\2\75\1\uffff\3\75\1"
+        u"\u017c\1\75\1\uffff\11\75\1\u0187\1\uffff"
+        )
+
+    DFA35_eof = DFA.unpack(
+        u"\u0188\uffff"
+        )
+
+    DFA35_min = DFA.unpack(
+        u"\1\3\1\uffff\1\171\1\uffff\1\75\1\154\1\150\1\165\1\145\1\124\1"
+        u"\157\1\141\1\146\1\157\1\154\1\145\1\156\3\uffff\1\116\1\120\1"
+        u"\117\1\116\1\117\1\114\1\106\4\uffff\1\75\1\56\1\53\1\55\1\52\1"
+        u"\75\1\46\1\uffff\1\75\1\74\3\75\1\uffff\1\137\1\150\1\157\1\162"
+        u"\1\42\1\uffff\2\0\2\56\2\uffff\1\0\2\uffff\1\160\4\uffff\1\164"
+        u"\1\165\1\163\1\141\1\157\1\147\1\151\1\164\1\147\1\101\1\151\1"
+        u"\156\1\141\1\163\1\164\1\44\1\156\1\162\1\157\1\44\1\146\1\151"
+        u"\3\uffff\1\44\2\124\1\116\1\101\1\114\1\117\1\111\34\uffff\1\75"
+        u"\2\uffff\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\3\uffff\1"
+        u"\56\1\uffff\1\56\3\uffff\2\145\1\155\1\145\1\165\1\164\1\162\1"
+        u"\156\1\145\1\164\1\157\1\151\1\165\1\124\1\141\1\144\1\163\1\162"
+        u"\1\145\1\44\1\uffff\1\147\1\44\1\141\1\142\1\uffff\1\141\1\151"
+        u"\1\157\1\uffff\1\111\1\44\1\123\1\114\1\101\1\102\1\101\4\uffff"
+        u"\1\163\1\155\1\154\1\157\1\141\1\uffff\1\144\1\162\2\44\1\143\1"
+        u"\151\1\164\1\145\1\157\1\143\1\44\1\163\1\162\1\111\1\164\1\44"
+        u"\1\151\1\164\2\44\1\uffff\1\44\1\uffff\1\164\1\154\1\165\1\147"
+        u"\1\156\1\117\1\uffff\1\124\1\111\1\124\1\101\1\102\1\120\1\155"
+        u"\1\44\1\145\1\44\1\153\1\145\1\156\2\uffff\1\164\1\143\1\44\1\144"
+        u"\1\146\1\150\1\uffff\1\164\1\156\1\103\1\151\1\uffff\1\156\1\44"
+        u"\3\uffff\1\44\1\145\1\154\1\156\1\44\1\116\1\44\1\107\1\111\1\114"
+        u"\1\125\1\117\1\111\1\44\1\uffff\1\44\1\uffff\1\44\1\146\3\44\1"
+        u"\uffff\3\44\1\145\2\44\1\154\1\165\2\uffff\1\44\1\164\1\145\1\uffff"
+        u"\1\101\1\uffff\1\116\1\114\1\137\1\116\1\117\1\44\3\uffff\1\44"
+        u"\6\uffff\1\162\2\uffff\2\145\1\uffff\1\44\1\144\1\114\2\105\1\122"
+        u"\2\124\2\uffff\3\44\1\uffff\2\44\1\104\1\44\1\105\1\111\1\123\5"
+        u"\uffff\1\44\1\uffff\2\115\1\105\1\uffff\1\117\1\105\1\122\1\126"
+        u"\1\123\1\126\2\105\1\111\1\137\1\122\1\103\1\111\1\126\1\105\1"
+        u"\106\1\111\1\44\1\137\1\103\1\uffff\1\125\1\105\1\116\1\44\1\122"
+        u"\1\uffff\1\105\1\106\1\105\1\122\1\105\1\116\1\103\1\105\1\104"
+        u"\1\44\1\uffff"
+        )
+
+    DFA35_max = DFA.unpack(
+        u"\1\ufffe\1\uffff\1\171\1\uffff\1\75\1\170\1\167\1\165\1\145\1\124"
+        u"\2\157\1\156\3\157\1\156\3\uffff\1\116\1\125\1\117\1\116\1\117"
+        u"\1\114\1\106\4\uffff\1\75\1\71\1\75\1\76\3\75\1\uffff\2\75\1\76"
+        u"\1\75\1\174\1\uffff\1\141\1\150\1\157\1\162\1\47\1\uffff\2\ufffe"
+        u"\1\170\1\146\2\uffff\1\ufffe\2\uffff\1\160\4\uffff\1\164\1\165"
+        u"\1\163\1\162\1\157\1\172\1\151\2\164\1\101\1\154\1\156\1\141\1"
+        u"\163\1\164\1\172\1\156\1\162\1\157\1\172\1\146\1\163\3\uffff\1"
+        u"\172\2\124\1\116\1\101\1\114\1\117\1\111\34\uffff\1\75\2\uffff"
+        u"\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\3\uffff\1\146\1\uffff"
+        u"\1\146\3\uffff\2\145\1\155\1\145\1\165\1\164\1\162\1\156\1\145"
+        u"\1\164\1\157\1\151\1\165\1\124\1\141\1\144\1\164\1\162\1\145\1"
+        u"\172\1\uffff\1\147\1\172\1\141\1\142\1\uffff\1\141\1\151\1\157"
+        u"\1\uffff\1\111\1\172\1\123\1\114\1\101\1\102\1\137\4\uffff\1\163"
+        u"\1\155\1\154\1\157\1\141\1\uffff\1\144\1\162\2\172\1\143\1\151"
+        u"\1\164\1\145\1\157\1\143\1\172\1\163\1\162\1\111\1\164\1\172\1"
+        u"\151\1\164\2\172\1\uffff\1\172\1\uffff\1\164\1\154\1\165\1\147"
+        u"\1\156\1\117\1\uffff\1\124\1\111\1\124\1\101\1\122\1\120\1\155"
+        u"\1\172\1\145\1\172\1\153\1\145\1\156\2\uffff\1\164\1\143\1\172"
+        u"\1\144\1\146\1\150\1\uffff\1\164\1\156\1\103\1\151\1\uffff\1\156"
+        u"\1\172\3\uffff\1\172\1\145\1\154\1\156\1\172\1\116\1\172\1\107"
+        u"\1\111\1\114\1\125\1\117\1\111\1\172\1\uffff\1\172\1\uffff\1\172"
+        u"\1\146\3\172\1\uffff\3\172\1\145\2\172\1\154\1\165\2\uffff\1\172"
+        u"\1\164\1\145\1\uffff\1\101\1\uffff\1\116\1\114\1\137\1\116\1\117"
+        u"\1\172\3\uffff\1\172\6\uffff\1\162\2\uffff\2\145\1\uffff\1\172"
+        u"\1\144\1\114\2\105\1\122\2\124\2\uffff\3\172\1\uffff\2\172\1\104"
+        u"\1\172\1\105\1\111\1\123\5\uffff\1\172\1\uffff\2\115\1\105\1\uffff"
+        u"\1\117\1\105\1\122\1\126\1\123\1\126\2\105\1\111\1\137\1\122\1"
+        u"\103\1\111\1\126\1\105\1\106\1\111\1\172\1\137\1\103\1\uffff\1"
+        u"\125\1\105\1\116\1\172\1\122\1\uffff\1\105\1\106\1\105\1\122\1"
+        u"\105\1\116\1\103\1\105\1\104\1\172\1\uffff"
+        )
+
+    DFA35_accept = DFA.unpack(
+        u"\1\uffff\1\1\1\uffff\1\3\15\uffff\1\23\1\24\1\27\7\uffff\1\45\1"
+        u"\46\1\47\1\50\7\uffff\1\65\5\uffff\1\101\5\uffff\1\134\4\uffff"
+        u"\1\143\1\144\1\uffff\1\145\1\1\1\uffff\1\134\1\3\1\106\1\4\26\uffff"
+        u"\1\23\1\24\1\27\10\uffff\1\45\1\46\1\47\1\50\1\67\1\51\1\52\1\142"
+        u"\1\62\1\57\1\72\1\53\1\60\1\73\1\63\1\54\1\146\1\147\1\70\1\55"
+        u"\1\71\1\56\1\103\1\76\1\64\1\65\1\107\1\66\1\uffff\1\112\1\110"
+        u"\1\uffff\1\113\1\111\1\77\1\105\1\102\1\100\1\104\1\101\5\uffff"
+        u"\1\135\1\136\1\137\1\uffff\1\140\1\uffff\1\143\1\144\1\150\24\uffff"
+        u"\1\122\4\uffff\1\126\3\uffff\1\33\7\uffff\1\74\1\114\1\75\1\115"
+        u"\5\uffff\1\141\24\uffff\1\15\1\uffff\1\127\6\uffff\1\34\15\uffff"
+        u"\1\30\1\123\6\uffff\1\7\4\uffff\1\12\2\uffff\1\13\1\120\1\16\16"
+        u"\uffff\1\116\1\uffff\1\130\5\uffff\1\14\10\uffff\1\31\1\17\3\uffff"
+        u"\1\26\1\uffff\1\36\6\uffff\1\117\1\125\1\132\1\uffff\1\5\1\25\1"
+        u"\6\1\21\1\61\1\124\1\uffff\1\133\1\11\2\uffff\1\20\10\uffff\1\42"
+        u"\1\2\3\uffff\1\121\7\uffff\1\10\1\32\1\131\1\22\1\35\1\uffff\1"
+        u"\40\3\uffff\1\37\24\uffff\1\43\5\uffff\1\44\12\uffff\1\41"
+        )
+
+    DFA35_special = DFA.unpack(
+        u"\u0188\uffff"
+        )
+
+
+    DFA35_transition = [
+        DFA.unpack(u"\6\72\2\67\1\72\2\67\22\72\1\67\1\47\1\64\1\71\1\62"
+        u"\1\44\1\45\1\63\1\33\1\34\1\37\1\41\1\3\1\42\1\40\1\43\1\65\11"
+        u"\66\1\23\1\1\1\50\1\4\1\51\1\54\1\72\2\62\1\26\1\62\1\32\1\62\1"
+        u"\31\1\62\1\24\2\62\1\61\2\62\1\25\3\62\1\11\1\62\1\27\1\30\4\62"
+        u"\1\35\1\70\1\36\1\52\1\55\1\72\1\7\1\60\1\13\1\17\1\5\1\16\1\57"
+        u"\1\62\1\14\2\62\1\15\5\62\1\10\1\6\1\2\1\20\1\12\1\56\3\62\1\21"
+        u"\1\53\1\22\1\46\uff80\72"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\74"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\77"),
+        DFA.unpack(u"\1\103\1\uffff\1\102\11\uffff\1\101"),
+        DFA.unpack(u"\1\105\1\106\12\uffff\1\104\2\uffff\1\107"),
+        DFA.unpack(u"\1\110"),
+        DFA.unpack(u"\1\111"),
+        DFA.unpack(u"\1\112"),
+        DFA.unpack(u"\1\113"),
+        DFA.unpack(u"\1\116\6\uffff\1\115\6\uffff\1\114"),
+        DFA.unpack(u"\1\120\7\uffff\1\117"),
+        DFA.unpack(u"\1\121"),
+        DFA.unpack(u"\1\123\2\uffff\1\122"),
+        DFA.unpack(u"\1\125\11\uffff\1\124"),
+        DFA.unpack(u"\1\126"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\132"),
+        DFA.unpack(u"\1\133\4\uffff\1\134"),
+        DFA.unpack(u"\1\135"),
+        DFA.unpack(u"\1\136"),
+        DFA.unpack(u"\1\137"),
+        DFA.unpack(u"\1\140"),
+        DFA.unpack(u"\1\141"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\146"),
+        DFA.unpack(u"\1\150\1\uffff\12\151"),
+        DFA.unpack(u"\1\153\21\uffff\1\154"),
+        DFA.unpack(u"\1\156\17\uffff\1\157\1\160"),
+        DFA.unpack(u"\1\162\4\uffff\1\163\15\uffff\1\164"),
+        DFA.unpack(u"\1\166"),
+        DFA.unpack(u"\1\170\26\uffff\1\171"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\174"),
+        DFA.unpack(u"\1\176\1\177"),
+        DFA.unpack(u"\1\u0082\1\u0081"),
+        DFA.unpack(u"\1\u0084"),
+        DFA.unpack(u"\1\u0087\76\uffff\1\u0086"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u008a\1\uffff\1\u008b"),
+        DFA.unpack(u"\1\u008c"),
+        DFA.unpack(u"\1\u008d"),
+        DFA.unpack(u"\1\u008e"),
+        DFA.unpack(u"\1\u0090\4\uffff\1\u008f"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\47\u008f\1\uffff\uffd7\u008f"),
+        DFA.unpack(u"\uffff\u0090"),
+        DFA.unpack(u"\1\151\1\uffff\10\u0092\2\151\12\uffff\3\151\21\uffff"
+        u"\1\u0091\13\uffff\3\151\21\uffff\1\u0091"),
+        DFA.unpack(u"\1\151\1\uffff\12\u0094\12\uffff\3\151\35\uffff\3\151"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\uffff\u0097"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0098"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0099"),
+        DFA.unpack(u"\1\u009a"),
+        DFA.unpack(u"\1\u009b"),
+        DFA.unpack(u"\1\u009d\20\uffff\1\u009c"),
+        DFA.unpack(u"\1\u009e"),
+        DFA.unpack(u"\1\u009f\22\uffff\1\u00a0"),
+        DFA.unpack(u"\1\u00a1"),
+        DFA.unpack(u"\1\u00a2"),
+        DFA.unpack(u"\1\u00a3\14\uffff\1\u00a4"),
+        DFA.unpack(u"\1\u00a5"),
+        DFA.unpack(u"\1\u00a7\2\uffff\1\u00a6"),
+        DFA.unpack(u"\1\u00a8"),
+        DFA.unpack(u"\1\u00a9"),
+        DFA.unpack(u"\1\u00aa"),
+        DFA.unpack(u"\1\u00ab"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u00ad"),
+        DFA.unpack(u"\1\u00ae"),
+        DFA.unpack(u"\1\u00af"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\24\75\1\u00b0\5\75"),
+        DFA.unpack(u"\1\u00b2"),
+        DFA.unpack(u"\1\u00b4\11\uffff\1\u00b3"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u00b6"),
+        DFA.unpack(u"\1\u00b7"),
+        DFA.unpack(u"\1\u00b8"),
+        DFA.unpack(u"\1\u00b9"),
+        DFA.unpack(u"\1\u00ba"),
+        DFA.unpack(u"\1\u00bb"),
+        DFA.unpack(u"\1\u00bc"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00bd"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00bf"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00c1"),
+        DFA.unpack(u"\1\u00c2"),
+        DFA.unpack(u"\1\u00c3"),
+        DFA.unpack(u"\1\u00c4"),
+        DFA.unpack(u"\1\u00c5"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\151\1\uffff\10\u0092\2\151\12\uffff\3\151\35\uffff"
+        u"\3\151"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\151\1\uffff\12\u0094\12\uffff\3\151\35\uffff\3\151"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00c7"),
+        DFA.unpack(u"\1\u00c8"),
+        DFA.unpack(u"\1\u00c9"),
+        DFA.unpack(u"\1\u00ca"),
+        DFA.unpack(u"\1\u00cb"),
+        DFA.unpack(u"\1\u00cc"),
+        DFA.unpack(u"\1\u00cd"),
+        DFA.unpack(u"\1\u00ce"),
+        DFA.unpack(u"\1\u00cf"),
+        DFA.unpack(u"\1\u00d0"),
+        DFA.unpack(u"\1\u00d1"),
+        DFA.unpack(u"\1\u00d2"),
+        DFA.unpack(u"\1\u00d3"),
+        DFA.unpack(u"\1\u00d4"),
+        DFA.unpack(u"\1\u00d5"),
+        DFA.unpack(u"\1\u00d6"),
+        DFA.unpack(u"\1\u00d8\1\u00d7"),
+        DFA.unpack(u"\1\u00d9"),
+        DFA.unpack(u"\1\u00da"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00dc"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u00de"),
+        DFA.unpack(u"\1\u00df"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00e0"),
+        DFA.unpack(u"\1\u00e1"),
+        DFA.unpack(u"\1\u00e2"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00e3"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u00e5"),
+        DFA.unpack(u"\1\u00e6"),
+        DFA.unpack(u"\1\u00e7"),
+        DFA.unpack(u"\1\u00e8"),
+        DFA.unpack(u"\1\u00ea\35\uffff\1\u00e9"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00eb"),
+        DFA.unpack(u"\1\u00ec"),
+        DFA.unpack(u"\1\u00ed"),
+        DFA.unpack(u"\1\u00ee"),
+        DFA.unpack(u"\1\u00ef"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u00f0"),
+        DFA.unpack(u"\1\u00f1"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u00f4"),
+        DFA.unpack(u"\1\u00f5"),
+        DFA.unpack(u"\1\u00f6"),
+        DFA.unpack(u"\1\u00f7"),
+        DFA.unpack(u"\1\u00f8"),
+        DFA.unpack(u"\1\u00f9"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u00fb"),
+        DFA.unpack(u"\1\u00fc"),
+        DFA.unpack(u"\1\u00fd"),
+        DFA.unpack(u"\1\u00fe"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0100"),
+        DFA.unpack(u"\1\u0101"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0105"),
+        DFA.unpack(u"\1\u0106"),
+        DFA.unpack(u"\1\u0107"),
+        DFA.unpack(u"\1\u0108"),
+        DFA.unpack(u"\1\u0109"),
+        DFA.unpack(u"\1\u010a"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u010b"),
+        DFA.unpack(u"\1\u010c"),
+        DFA.unpack(u"\1\u010d"),
+        DFA.unpack(u"\1\u010e"),
+        DFA.unpack(u"\1\u0110\17\uffff\1\u010f"),
+        DFA.unpack(u"\1\u0111"),
+        DFA.unpack(u"\1\u0112"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0114"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0116"),
+        DFA.unpack(u"\1\u0117"),
+        DFA.unpack(u"\1\u0118"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0119"),
+        DFA.unpack(u"\1\u011a"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u011c"),
+        DFA.unpack(u"\1\u011d"),
+        DFA.unpack(u"\1\u011e"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u011f"),
+        DFA.unpack(u"\1\u0120"),
+        DFA.unpack(u"\1\u0121"),
+        DFA.unpack(u"\1\u0122"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0123"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0126"),
+        DFA.unpack(u"\1\u0127"),
+        DFA.unpack(u"\1\u0128"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u012a"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u012c"),
+        DFA.unpack(u"\1\u012d"),
+        DFA.unpack(u"\1\u012e"),
+        DFA.unpack(u"\1\u012f"),
+        DFA.unpack(u"\1\u0130"),
+        DFA.unpack(u"\1\u0131"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0135"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u013c"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u013f"),
+        DFA.unpack(u"\1\u0140"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0142"),
+        DFA.unpack(u"\1\u0143"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0144"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0145"),
+        DFA.unpack(u"\1\u0146"),
+        DFA.unpack(u"\1\u0147"),
+        DFA.unpack(u"\1\u0148"),
+        DFA.unpack(u"\1\u0149"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u014c"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u014d"),
+        DFA.unpack(u"\1\u014e"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0150"),
+        DFA.unpack(u"\1\u0151"),
+        DFA.unpack(u"\1\u0152"),
+        DFA.unpack(u"\1\u0153"),
+        DFA.unpack(u"\1\u0154"),
+        DFA.unpack(u"\1\u0155"),
+        DFA.unpack(u"\1\u0156"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u015c"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u015e"),
+        DFA.unpack(u"\1\u015f"),
+        DFA.unpack(u"\1\u0160"),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0162"),
+        DFA.unpack(u"\1\u0163"),
+        DFA.unpack(u"\1\u0164"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0165"),
+        DFA.unpack(u"\1\u0166"),
+        DFA.unpack(u"\1\u0167"),
+        DFA.unpack(u"\1\u0168"),
+        DFA.unpack(u"\1\u0169"),
+        DFA.unpack(u"\1\u016a"),
+        DFA.unpack(u"\1\u016b"),
+        DFA.unpack(u"\1\u016c"),
+        DFA.unpack(u"\1\u016d"),
+        DFA.unpack(u"\1\u016e"),
+        DFA.unpack(u"\1\u016f"),
+        DFA.unpack(u"\1\u0170"),
+        DFA.unpack(u"\1\u0171"),
+        DFA.unpack(u"\1\u0172"),
+        DFA.unpack(u"\1\u0173"),
+        DFA.unpack(u"\1\u0174"),
+        DFA.unpack(u"\1\u0175"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u0177"),
+        DFA.unpack(u"\1\u0178"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u0179"),
+        DFA.unpack(u"\1\u017a"),
+        DFA.unpack(u"\1\u017b"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"\1\u017d"),
+        DFA.unpack(u""),
+        DFA.unpack(u"\1\u017e"),
+        DFA.unpack(u"\1\u017f"),
+        DFA.unpack(u"\1\u0180"),
+        DFA.unpack(u"\1\u0181"),
+        DFA.unpack(u"\1\u0182"),
+        DFA.unpack(u"\1\u0183"),
+        DFA.unpack(u"\1\u0184"),
+        DFA.unpack(u"\1\u0185"),
+        DFA.unpack(u"\1\u0186"),
+        DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
+        u"\32\75"),
+        DFA.unpack(u"")
+    ]
+
+    # class definition for DFA #35
+
+    DFA35 = DFA
+
+
diff --git a/Source/Python/Eot/CParser.py b/Source/Python/Eot/CParser.py
new file mode 100644 (file)
index 0000000..257e590
--- /dev/null
@@ -0,0 +1,18671 @@
+# $ANTLR 3.0.1 C.g 2008-06-04 15:55:52
+
+from antlr3 import *
+from antlr3.compat import set, frozenset
+\r
+import CodeFragment\r
+import FileProfile\r
+
+
+
+# for convenience in actions
+HIDDEN = BaseRecognizer.HIDDEN
+
+# token types
+BS=20
+LINE_COMMENT=23
+FloatTypeSuffix=16
+IntegerTypeSuffix=14
+LETTER=11
+OCTAL_LITERAL=6
+CHARACTER_LITERAL=8
+Exponent=15
+EOF=-1
+HexDigit=13
+STRING_LITERAL=9
+WS=19
+FLOATING_POINT_LITERAL=10
+IDENTIFIER=4
+UnicodeEscape=18
+LINE_COMMAND=24
+UnicodeVocabulary=21
+HEX_LITERAL=5
+COMMENT=22
+DECIMAL_LITERAL=7
+EscapeSequence=12
+OctalEscape=17
+
+# token names
+tokenNames = [
+    "<invalid>", "<EOR>", "<DOWN>", "<UP>",
+    "IDENTIFIER", "HEX_LITERAL", "OCTAL_LITERAL", "DECIMAL_LITERAL", "CHARACTER_LITERAL",
+    "STRING_LITERAL", "FLOATING_POINT_LITERAL", "LETTER", "EscapeSequence",
+    "HexDigit", "IntegerTypeSuffix", "Exponent", "FloatTypeSuffix", "OctalEscape",
+    "UnicodeEscape", "WS", "BS", "UnicodeVocabulary", "COMMENT", "LINE_COMMENT",
+    "LINE_COMMAND", "';'", "'typedef'", "','", "'='", "'extern'", "'static'",
+    "'auto'", "'register'", "'STATIC'", "'void'", "'char'", "'short'", "'int'",
+    "'long'", "'float'", "'double'", "'signed'", "'unsigned'", "'{'", "'}'",
+    "'struct'", "'union'", "':'", "'enum'", "'const'", "'volatile'", "'IN'",
+    "'OUT'", "'OPTIONAL'", "'CONST'", "'UNALIGNED'", "'VOLATILE'", "'GLOBAL_REMOVE_IF_UNREFERENCED'",
+    "'EFIAPI'", "'EFI_BOOTSERVICE'", "'EFI_RUNTIMESERVICE'", "'('", "')'",
+    "'['", "']'", "'*'", "'...'", "'+'", "'-'", "'/'", "'%'", "'++'", "'--'",
+    "'sizeof'", "'.'", "'->'", "'&'", "'~'", "'!'", "'*='", "'/='", "'%='",
+    "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='", "'?'", "'||'",
+    "'&&'", "'|'", "'^'", "'=='", "'!='", "'<'", "'>'", "'<='", "'>='",
+    "'<<'", "'>>'", "'_asm'", "'__asm'", "'case'", "'default'", "'if'",
+    "'else'", "'switch'", "'while'", "'do'", "'for'", "'goto'", "'continue'",
+    "'break'", "'return'"
+]
+
+
+class function_definition_scope(object):
+    def __init__(self):
+        self.ModifierText = None
+        self.DeclText = None
+        self.LBLine = None
+        self.LBOffset = None
+        self.DeclLine = None
+        self.DeclOffset = None
+class postfix_expression_scope(object):
+    def __init__(self):
+        self.FuncCallText = None
+
+
+class CParser(Parser):
+    grammarFileName = "C.g"
+    tokenNames = tokenNames
+
+    def __init__(self, input):
+        Parser.__init__(self, input)
+        self.ruleMemo = {}
+
+       self.function_definition_stack = []
+       self.postfix_expression_stack = []
+
+
+
+
+
+
+\r
+\r
+    def printTokenInfo(self, line, offset, tokenText):\r
+       print str(line)+ ',' + str(offset) + ':' + str(tokenText)\r
+\r
+    def StoreAssignmentExpression(self, StartLine, StartOffset, EndLine, EndOffset, Name, Op, Value):\r
+       AssignExp = CodeFragment.AssignmentExpression(Name, Op, Value, (StartLine, StartOffset), (EndLine, EndOffset))\r
+       FileProfile.AssignmentExpressionList.append(AssignExp)\r
+\r
+    def StoreEnumerationDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text):\r
+       EnumDef = CodeFragment.EnumerationDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))\r
+       FileProfile.EnumerationDefinitionList.append(EnumDef)\r
+\r
+    def StoreStructUnionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, Text):\r
+       SUDef = CodeFragment.StructUnionDefinition(Text, (StartLine, StartOffset), (EndLine, EndOffset))\r
+       FileProfile.StructUnionDefinitionList.append(SUDef)\r
+\r
+    def StoreTypedefDefinition(self, StartLine, StartOffset, EndLine, EndOffset, FromText, ToText):\r
+       Tdef = CodeFragment.TypedefDefinition(FromText, ToText, (StartLine, StartOffset), (EndLine, EndOffset))\r
+       FileProfile.TypedefDefinitionList.append(Tdef)\r
+\r
+    def StoreFunctionDefinition(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText, LeftBraceLine, LeftBraceOffset, DeclLine, DeclOffset):\r
+       FuncDef = CodeFragment.FunctionDefinition(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset), (LeftBraceLine, LeftBraceOffset), (DeclLine, DeclOffset))\r
+       FileProfile.FunctionDefinitionList.append(FuncDef)\r
+\r
+    def StoreVariableDeclaration(self, StartLine, StartOffset, EndLine, EndOffset, ModifierText, DeclText):\r
+       VarDecl = CodeFragment.VariableDeclaration(ModifierText, DeclText, (StartLine, StartOffset), (EndLine, EndOffset))\r
+       FileProfile.VariableDeclarationList.append(VarDecl)\r
+\r
+    def StoreFunctionCalling(self, StartLine, StartOffset, EndLine, EndOffset, FuncName, ParamList):\r
+       FuncCall = CodeFragment.FunctionCalling(FuncName, ParamList, (StartLine, StartOffset), (EndLine, EndOffset))\r
+       FileProfile.FunctionCallingList.append(FuncCall)\r
+\r
+
+
+
+    # $ANTLR start translation_unit
+    # C.g:50:1: translation_unit : ( external_declaration )* ;
+    def translation_unit(self, ):
+
+        translation_unit_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 1):
+                    return
+
+                # C.g:51:2: ( ( external_declaration )* )
+                # C.g:51:4: ( external_declaration )*
+                # C.g:51:4: ( external_declaration )*
+                while True: #loop1
+                    alt1 = 2
+                    LA1_0 = self.input.LA(1)
+
+                    if (LA1_0 == IDENTIFIER or LA1_0 == 26 or (29 <= LA1_0 <= 42) or (45 <= LA1_0 <= 46) or (48 <= LA1_0 <= 61) or LA1_0 == 65) :
+                        alt1 = 1
+
+
+                    if alt1 == 1:
+                        # C.g:0:0: external_declaration
+                        self.following.append(self.FOLLOW_external_declaration_in_translation_unit64)
+                        self.external_declaration()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    else:
+                        break #loop1
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 1, translation_unit_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end translation_unit
+
+
+    # $ANTLR start external_declaration
+    # C.g:62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );
+    def external_declaration(self, ):
+
+        external_declaration_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 2):
+                    return
+
+                # C.g:67:2: ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? )
+                alt3 = 3
+                LA3_0 = self.input.LA(1)
+
+                if ((29 <= LA3_0 <= 33)) :
+                    LA3_1 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 1, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 34) :
+                    LA3_2 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 2, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 35) :
+                    LA3_3 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 3, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 36) :
+                    LA3_4 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 4, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 37) :
+                    LA3_5 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 5, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 38) :
+                    LA3_6 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 6, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 39) :
+                    LA3_7 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 7, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 40) :
+                    LA3_8 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 8, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 41) :
+                    LA3_9 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 9, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 42) :
+                    LA3_10 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 10, self.input)
+
+                        raise nvae
+
+                elif ((45 <= LA3_0 <= 46)) :
+                    LA3_11 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 11, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 48) :
+                    LA3_12 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 12, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == IDENTIFIER) :
+                    LA3_13 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    elif (True) :
+                        alt3 = 3
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 13, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 58) :
+                    LA3_14 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 14, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 65) and (self.synpred4()):
+                    alt3 = 1
+                elif (LA3_0 == 59) :
+                    LA3_16 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 16, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 60) :
+                    LA3_17 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 17, self.input)
+
+                        raise nvae
+
+                elif ((49 <= LA3_0 <= 57)) :
+                    LA3_18 = self.input.LA(2)
+
+                    if (self.synpred4()) :
+                        alt3 = 1
+                    elif (self.synpred5()) :
+                        alt3 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 18, self.input)
+
+                        raise nvae
+
+                elif (LA3_0 == 61) and (self.synpred4()):
+                    alt3 = 1
+                elif (LA3_0 == 26) :
+                    alt3 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("62:1: external_declaration options {k=1; } : ( ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition | declaration | macro_statement ( ';' )? );", 3, 0, self.input)
+
+                    raise nvae
+
+                if alt3 == 1:
+                    # C.g:67:4: ( ( declaration_specifiers )? declarator ( declaration )* '{' )=> function_definition
+                    self.following.append(self.FOLLOW_function_definition_in_external_declaration103)
+                    self.function_definition()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+                elif alt3 == 2:
+                    # C.g:68:4: declaration
+                    self.following.append(self.FOLLOW_declaration_in_external_declaration108)
+                    self.declaration()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+                elif alt3 == 3:
+                    # C.g:69:4: macro_statement ( ';' )?
+                    self.following.append(self.FOLLOW_macro_statement_in_external_declaration113)
+                    self.macro_statement()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    # C.g:69:20: ( ';' )?
+                    alt2 = 2
+                    LA2_0 = self.input.LA(1)
+
+                    if (LA2_0 == 25) :
+                        alt2 = 1
+                    if alt2 == 1:
+                        # C.g:69:21: ';'
+                        self.match(self.input, 25, self.FOLLOW_25_in_external_declaration116)
+                        if self.failed:
+                            return
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 2, external_declaration_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end external_declaration
+
+    class function_definition_return(object):
+        def __init__(self):
+            self.start = None
+            self.stop = None
+
+
+
+    # $ANTLR start function_definition
+    # C.g:74:1: function_definition : (d= declaration_specifiers )? declarator ( ( declaration )+ a= compound_statement | b= compound_statement ) ;
+    def function_definition(self, ):
+        self.function_definition_stack.append(function_definition_scope())
+        retval = self.function_definition_return()
+        retval.start = self.input.LT(1)
+        function_definition_StartIndex = self.input.index()
+        d = None
+
+        a = None
+
+        b = None
+
+        declarator1 = None
+
+
+\r
+        self.function_definition_stack[-1].ModifierText =  ''\r
+        self.function_definition_stack[-1].DeclText =  ''\r
+        self.function_definition_stack[-1].LBLine =  0\r
+        self.function_definition_stack[-1].LBOffset =  0\r
+        self.function_definition_stack[-1].DeclLine =  0\r
+        self.function_definition_stack[-1].DeclOffset =  0\r
+
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 3):
+                    return retval
+
+                # C.g:94:2: ( (d= declaration_specifiers )? declarator ( ( declaration )+ a= compound_statement | b= compound_statement ) )
+                # C.g:94:4: (d= declaration_specifiers )? declarator ( ( declaration )+ a= compound_statement | b= compound_statement )
+                # C.g:94:5: (d= declaration_specifiers )?
+                alt4 = 2
+                LA4 = self.input.LA(1)
+                if LA4 == 29 or LA4 == 30 or LA4 == 31 or LA4 == 32 or LA4 == 33 or LA4 == 34 or LA4 == 35 or LA4 == 36 or LA4 == 37 or LA4 == 38 or LA4 == 39 or LA4 == 40 or LA4 == 41 or LA4 == 42 or LA4 == 45 or LA4 == 46 or LA4 == 48 or LA4 == 49 or LA4 == 50 or LA4 == 51 or LA4 == 52 or LA4 == 53 or LA4 == 54 or LA4 == 55 or LA4 == 56 or LA4 == 57:
+                    alt4 = 1
+                elif LA4 == IDENTIFIER:
+                    LA4 = self.input.LA(2)
+                    if LA4 == 61:
+                        LA4_21 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 29 or LA4 == 30 or LA4 == 31 or LA4 == 32 or LA4 == 33:
+                        LA4_23 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 34:
+                        LA4_24 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 35:
+                        LA4_25 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 36:
+                        LA4_26 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 37:
+                        LA4_27 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 38:
+                        LA4_28 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 39:
+                        LA4_29 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 40:
+                        LA4_30 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 41:
+                        LA4_31 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 42:
+                        LA4_32 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 45 or LA4 == 46:
+                        LA4_33 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 48:
+                        LA4_34 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == IDENTIFIER:
+                        LA4_35 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 58:
+                        LA4_36 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 65:
+                        alt4 = 1
+                    elif LA4 == 59:
+                        LA4_39 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 60:
+                        LA4_40 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                    elif LA4 == 49 or LA4 == 50 or LA4 == 51 or LA4 == 52 or LA4 == 53 or LA4 == 54 or LA4 == 55 or LA4 == 56 or LA4 == 57:
+                        LA4_41 = self.input.LA(3)
+
+                        if (self.synpred7()) :
+                            alt4 = 1
+                elif LA4 == 58:
+                    LA4_14 = self.input.LA(2)
+
+                    if (self.synpred7()) :
+                        alt4 = 1
+                elif LA4 == 59:
+                    LA4_16 = self.input.LA(2)
+
+                    if (self.synpred7()) :
+                        alt4 = 1
+                elif LA4 == 60:
+                    LA4_17 = self.input.LA(2)
+
+                    if (self.synpred7()) :
+                        alt4 = 1
+                if alt4 == 1:
+                    # C.g:0:0: d= declaration_specifiers
+                    self.following.append(self.FOLLOW_declaration_specifiers_in_function_definition147)
+                    d = self.declaration_specifiers()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+
+
+
+                self.following.append(self.FOLLOW_declarator_in_function_definition150)
+                declarator1 = self.declarator()
+                self.following.pop()
+                if self.failed:
+                    return retval
+                # C.g:95:3: ( ( declaration )+ a= compound_statement | b= compound_statement )
+                alt6 = 2
+                LA6_0 = self.input.LA(1)
+
+                if (LA6_0 == IDENTIFIER or LA6_0 == 26 or (29 <= LA6_0 <= 42) or (45 <= LA6_0 <= 46) or (48 <= LA6_0 <= 60)) :
+                    alt6 = 1
+                elif (LA6_0 == 43) :
+                    alt6 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return retval
+
+                    nvae = NoViableAltException("95:3: ( ( declaration )+ a= compound_statement | b= compound_statement )", 6, 0, self.input)
+
+                    raise nvae
+
+                if alt6 == 1:
+                    # C.g:95:5: ( declaration )+ a= compound_statement
+                    # C.g:95:5: ( declaration )+
+                    cnt5 = 0
+                    while True: #loop5
+                        alt5 = 2
+                        LA5_0 = self.input.LA(1)
+
+                        if (LA5_0 == IDENTIFIER or LA5_0 == 26 or (29 <= LA5_0 <= 42) or (45 <= LA5_0 <= 46) or (48 <= LA5_0 <= 60)) :
+                            alt5 = 1
+
+
+                        if alt5 == 1:
+                            # C.g:0:0: declaration
+                            self.following.append(self.FOLLOW_declaration_in_function_definition156)
+                            self.declaration()
+                            self.following.pop()
+                            if self.failed:
+                                return retval
+
+
+                        else:
+                            if cnt5 >= 1:
+                                break #loop5
+
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return retval
+
+                            eee = EarlyExitException(5, self.input)
+                            raise eee
+
+                        cnt5 += 1
+
+
+                    self.following.append(self.FOLLOW_compound_statement_in_function_definition161)
+                    a = self.compound_statement()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+
+
+                elif alt6 == 2:
+                    # C.g:96:5: b= compound_statement
+                    self.following.append(self.FOLLOW_compound_statement_in_function_definition170)
+                    b = self.compound_statement()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+
+
+
+                if self.backtracking == 0:
+\r
+                    if d != None:\r
+                      self.function_definition_stack[-1].ModifierText = self.input.toString(d.start,d.stop)\r
+                    else:\r
+                      self.function_definition_stack[-1].ModifierText = ''\r
+                    self.function_definition_stack[-1].DeclText = self.input.toString(declarator1.start,declarator1.stop)\r
+                    self.function_definition_stack[-1].DeclLine = declarator1.start.line\r
+                    self.function_definition_stack[-1].DeclOffset = declarator1.start.charPositionInLine\r
+                    if a != None:\r
+                      self.function_definition_stack[-1].LBLine = a.start.line\r
+                      self.function_definition_stack[-1].LBOffset = a.start.charPositionInLine\r
+                    else:\r
+                      self.function_definition_stack[-1].LBLine = b.start.line\r
+                      self.function_definition_stack[-1].LBOffset = b.start.charPositionInLine\r
+
+
+
+
+
+                retval.stop = self.input.LT(-1)
+
+                if self.backtracking == 0:
+\r
+                    self.StoreFunctionDefinition(retval.start.line, retval.start.charPositionInLine, retval.stop.line, retval.stop.charPositionInLine, self.function_definition_stack[-1].ModifierText, self.function_definition_stack[-1].DeclText, self.function_definition_stack[-1].LBLine, self.function_definition_stack[-1].LBOffset, self.function_definition_stack[-1].DeclLine, self.function_definition_stack[-1].DeclOffset)\r
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 3, function_definition_StartIndex)
+
+            self.function_definition_stack.pop()
+            pass
+
+        return retval
+
+    # $ANTLR end function_definition
+
+
+    # $ANTLR start declaration
+    # C.g:114:1: declaration : (a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' | s= declaration_specifiers (t= init_declarator_list )? e= ';' );
+    def declaration(self, ):
+
+        declaration_StartIndex = self.input.index()
+        a = None
+        d = None
+        e = None
+        b = None
+
+        c = None
+
+        s = None
+
+        t = None
+
+
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 4):
+                    return
+
+                # C.g:115:2: (a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' | s= declaration_specifiers (t= init_declarator_list )? e= ';' )
+                alt9 = 2
+                LA9_0 = self.input.LA(1)
+
+                if (LA9_0 == 26) :
+                    alt9 = 1
+                elif (LA9_0 == IDENTIFIER or (29 <= LA9_0 <= 42) or (45 <= LA9_0 <= 46) or (48 <= LA9_0 <= 60)) :
+                    alt9 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("114:1: declaration : (a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';' | s= declaration_specifiers (t= init_declarator_list )? e= ';' );", 9, 0, self.input)
+
+                    raise nvae
+
+                if alt9 == 1:
+                    # C.g:115:4: a= 'typedef' (b= declaration_specifiers )? c= init_declarator_list d= ';'
+                    a = self.input.LT(1)
+                    self.match(self.input, 26, self.FOLLOW_26_in_declaration193)
+                    if self.failed:
+                        return
+                    # C.g:115:17: (b= declaration_specifiers )?
+                    alt7 = 2
+                    LA7 = self.input.LA(1)
+                    if LA7 == 29 or LA7 == 30 or LA7 == 31 or LA7 == 32 or LA7 == 33 or LA7 == 34 or LA7 == 35 or LA7 == 36 or LA7 == 37 or LA7 == 38 or LA7 == 39 or LA7 == 40 or LA7 == 41 or LA7 == 42 or LA7 == 45 or LA7 == 46 or LA7 == 48 or LA7 == 49 or LA7 == 50 or LA7 == 51 or LA7 == 52 or LA7 == 53 or LA7 == 54 or LA7 == 55 or LA7 == 56 or LA7 == 57:
+                        alt7 = 1
+                    elif LA7 == IDENTIFIER:
+                        LA7_13 = self.input.LA(2)
+
+                        if (LA7_13 == 61) :
+                            LA7_21 = self.input.LA(3)
+
+                            if (self.synpred10()) :
+                                alt7 = 1
+                        elif (LA7_13 == IDENTIFIER or (29 <= LA7_13 <= 42) or (45 <= LA7_13 <= 46) or (48 <= LA7_13 <= 60) or LA7_13 == 65) :
+                            alt7 = 1
+                    elif LA7 == 58:
+                        LA7_14 = self.input.LA(2)
+
+                        if (self.synpred10()) :
+                            alt7 = 1
+                    elif LA7 == 59:
+                        LA7_16 = self.input.LA(2)
+
+                        if (self.synpred10()) :
+                            alt7 = 1
+                    elif LA7 == 60:
+                        LA7_17 = self.input.LA(2)
+
+                        if (self.synpred10()) :
+                            alt7 = 1
+                    if alt7 == 1:
+                        # C.g:0:0: b= declaration_specifiers
+                        self.following.append(self.FOLLOW_declaration_specifiers_in_declaration197)
+                        b = self.declaration_specifiers()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+
+                    self.following.append(self.FOLLOW_init_declarator_list_in_declaration206)
+                    c = self.init_declarator_list()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    d = self.input.LT(1)
+                    self.match(self.input, 25, self.FOLLOW_25_in_declaration210)
+                    if self.failed:
+                        return
+                    if self.backtracking == 0:
+\r
+                        if b != None:\r
+                          self.StoreTypedefDefinition(a.line, a.charPositionInLine, d.line, d.charPositionInLine, self.input.toString(b.start,b.stop), self.input.toString(c.start,c.stop))\r
+                        else:\r
+                          self.StoreTypedefDefinition(a.line, a.charPositionInLine, d.line, d.charPositionInLine, '', self.input.toString(c.start,c.stop))\r
+
+
+
+
+                elif alt9 == 2:
+                    # C.g:123:4: s= declaration_specifiers (t= init_declarator_list )? e= ';'
+                    self.following.append(self.FOLLOW_declaration_specifiers_in_declaration224)
+                    s = self.declaration_specifiers()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    # C.g:123:30: (t= init_declarator_list )?
+                    alt8 = 2
+                    LA8_0 = self.input.LA(1)
+
+                    if (LA8_0 == IDENTIFIER or (58 <= LA8_0 <= 61) or LA8_0 == 65) :
+                        alt8 = 1
+                    if alt8 == 1:
+                        # C.g:0:0: t= init_declarator_list
+                        self.following.append(self.FOLLOW_init_declarator_list_in_declaration228)
+                        t = self.init_declarator_list()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+
+                    e = self.input.LT(1)
+                    self.match(self.input, 25, self.FOLLOW_25_in_declaration233)
+                    if self.failed:
+                        return
+                    if self.backtracking == 0:
+\r
+                        if t != None:\r
+                          self.StoreVariableDeclaration(s.start.line, s.start.charPositionInLine, e.line, e.charPositionInLine, self.input.toString(s.start,s.stop), self.input.toString(t.start,t.stop))\r
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 4, declaration_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end declaration
+
+    class declaration_specifiers_return(object):
+        def __init__(self):
+            self.start = None
+            self.stop = None
+
+
+
+    # $ANTLR start declaration_specifiers
+    # C.g:130:1: declaration_specifiers : ( storage_class_specifier | type_specifier | type_qualifier )+ ;
+    def declaration_specifiers(self, ):
+
+        retval = self.declaration_specifiers_return()
+        retval.start = self.input.LT(1)
+        declaration_specifiers_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 5):
+                    return retval
+
+                # C.g:131:2: ( ( storage_class_specifier | type_specifier | type_qualifier )+ )
+                # C.g:131:6: ( storage_class_specifier | type_specifier | type_qualifier )+
+                # C.g:131:6: ( storage_class_specifier | type_specifier | type_qualifier )+
+                cnt10 = 0
+                while True: #loop10
+                    alt10 = 4
+                    LA10 = self.input.LA(1)
+                    if LA10 == 58:
+                        LA10_2 = self.input.LA(2)
+
+                        if (self.synpred15()) :
+                            alt10 = 3
+
+
+                    elif LA10 == 59:
+                        LA10_3 = self.input.LA(2)
+
+                        if (self.synpred15()) :
+                            alt10 = 3
+
+
+                    elif LA10 == 60:
+                        LA10_4 = self.input.LA(2)
+
+                        if (self.synpred15()) :
+                            alt10 = 3
+
+
+                    elif LA10 == IDENTIFIER:
+                        LA10_5 = self.input.LA(2)
+
+                        if (self.synpred14()) :
+                            alt10 = 2
+
+
+                    elif LA10 == 53:
+                        LA10_9 = self.input.LA(2)
+
+                        if (self.synpred15()) :
+                            alt10 = 3
+
+
+                    elif LA10 == 29 or LA10 == 30 or LA10 == 31 or LA10 == 32 or LA10 == 33:
+                        alt10 = 1
+                    elif LA10 == 34 or LA10 == 35 or LA10 == 36 or LA10 == 37 or LA10 == 38 or LA10 == 39 or LA10 == 40 or LA10 == 41 or LA10 == 42 or LA10 == 45 or LA10 == 46 or LA10 == 48:
+                        alt10 = 2
+                    elif LA10 == 49 or LA10 == 50 or LA10 == 51 or LA10 == 52 or LA10 == 54 or LA10 == 55 or LA10 == 56 or LA10 == 57:
+                        alt10 = 3
+
+                    if alt10 == 1:
+                        # C.g:131:10: storage_class_specifier
+                        self.following.append(self.FOLLOW_storage_class_specifier_in_declaration_specifiers254)
+                        self.storage_class_specifier()
+                        self.following.pop()
+                        if self.failed:
+                            return retval
+
+
+                    elif alt10 == 2:
+                        # C.g:132:7: type_specifier
+                        self.following.append(self.FOLLOW_type_specifier_in_declaration_specifiers262)
+                        self.type_specifier()
+                        self.following.pop()
+                        if self.failed:
+                            return retval
+
+
+                    elif alt10 == 3:
+                        # C.g:133:13: type_qualifier
+                        self.following.append(self.FOLLOW_type_qualifier_in_declaration_specifiers276)
+                        self.type_qualifier()
+                        self.following.pop()
+                        if self.failed:
+                            return retval
+
+
+                    else:
+                        if cnt10 >= 1:
+                            break #loop10
+
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return retval
+
+                        eee = EarlyExitException(10, self.input)
+                        raise eee
+
+                    cnt10 += 1
+
+
+
+
+
+                retval.stop = self.input.LT(-1)
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 5, declaration_specifiers_StartIndex)
+
+            pass
+
+        return retval
+
+    # $ANTLR end declaration_specifiers
+
+    class init_declarator_list_return(object):
+        def __init__(self):
+            self.start = None
+            self.stop = None
+
+
+
+    # $ANTLR start init_declarator_list
+    # C.g:137:1: init_declarator_list : init_declarator ( ',' init_declarator )* ;
+    def init_declarator_list(self, ):
+
+        retval = self.init_declarator_list_return()
+        retval.start = self.input.LT(1)
+        init_declarator_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 6):
+                    return retval
+
+                # C.g:138:2: ( init_declarator ( ',' init_declarator )* )
+                # C.g:138:4: init_declarator ( ',' init_declarator )*
+                self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list298)
+                self.init_declarator()
+                self.following.pop()
+                if self.failed:
+                    return retval
+                # C.g:138:20: ( ',' init_declarator )*
+                while True: #loop11
+                    alt11 = 2
+                    LA11_0 = self.input.LA(1)
+
+                    if (LA11_0 == 27) :
+                        alt11 = 1
+
+
+                    if alt11 == 1:
+                        # C.g:138:21: ',' init_declarator
+                        self.match(self.input, 27, self.FOLLOW_27_in_init_declarator_list301)
+                        if self.failed:
+                            return retval
+                        self.following.append(self.FOLLOW_init_declarator_in_init_declarator_list303)
+                        self.init_declarator()
+                        self.following.pop()
+                        if self.failed:
+                            return retval
+
+
+                    else:
+                        break #loop11
+
+
+
+
+
+                retval.stop = self.input.LT(-1)
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 6, init_declarator_list_StartIndex)
+
+            pass
+
+        return retval
+
+    # $ANTLR end init_declarator_list
+
+
+    # $ANTLR start init_declarator
+    # C.g:141:1: init_declarator : declarator ( '=' initializer )? ;
+    def init_declarator(self, ):
+
+        init_declarator_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 7):
+                    return
+
+                # C.g:142:2: ( declarator ( '=' initializer )? )
+                # C.g:142:4: declarator ( '=' initializer )?
+                self.following.append(self.FOLLOW_declarator_in_init_declarator316)
+                self.declarator()
+                self.following.pop()
+                if self.failed:
+                    return
+                # C.g:142:15: ( '=' initializer )?
+                alt12 = 2
+                LA12_0 = self.input.LA(1)
+
+                if (LA12_0 == 28) :
+                    alt12 = 1
+                if alt12 == 1:
+                    # C.g:142:16: '=' initializer
+                    self.match(self.input, 28, self.FOLLOW_28_in_init_declarator319)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_initializer_in_init_declarator321)
+                    self.initializer()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 7, init_declarator_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end init_declarator
+
+
+    # $ANTLR start storage_class_specifier
+    # C.g:145:1: storage_class_specifier : ( 'extern' | 'static' | 'auto' | 'register' | 'STATIC' );
+    def storage_class_specifier(self, ):
+
+        storage_class_specifier_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 8):
+                    return
+
+                # C.g:146:2: ( 'extern' | 'static' | 'auto' | 'register' | 'STATIC' )
+                # C.g:
+                if (29 <= self.input.LA(1) <= 33):
+                    self.input.consume();
+                    self.errorRecovery = False
+                    self.failed = False
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    mse = MismatchedSetException(None, self.input)
+                    self.recoverFromMismatchedSet(
+                        self.input, mse, self.FOLLOW_set_in_storage_class_specifier0
+                        )
+                    raise mse
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 8, storage_class_specifier_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end storage_class_specifier
+
+
+    # $ANTLR start type_specifier
+    # C.g:153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER ( type_qualifier )* declarator )=> type_id );
+    def type_specifier(self, ):
+
+        type_specifier_StartIndex = self.input.index()
+        s = None
+
+        e = None
+
+
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 9):
+                    return
+
+                # C.g:154:2: ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER ( type_qualifier )* declarator )=> type_id )
+                alt13 = 12
+                LA13_0 = self.input.LA(1)
+
+                if (LA13_0 == 34) :
+                    alt13 = 1
+                elif (LA13_0 == 35) :
+                    alt13 = 2
+                elif (LA13_0 == 36) :
+                    alt13 = 3
+                elif (LA13_0 == 37) :
+                    alt13 = 4
+                elif (LA13_0 == 38) :
+                    alt13 = 5
+                elif (LA13_0 == 39) :
+                    alt13 = 6
+                elif (LA13_0 == 40) :
+                    alt13 = 7
+                elif (LA13_0 == 41) :
+                    alt13 = 8
+                elif (LA13_0 == 42) :
+                    alt13 = 9
+                elif ((45 <= LA13_0 <= 46)) :
+                    alt13 = 10
+                elif (LA13_0 == 48) :
+                    alt13 = 11
+                elif (LA13_0 == IDENTIFIER) and (self.synpred34()):
+                    alt13 = 12
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("153:1: type_specifier : ( 'void' | 'char' | 'short' | 'int' | 'long' | 'float' | 'double' | 'signed' | 'unsigned' | s= struct_or_union_specifier | e= enum_specifier | ( IDENTIFIER ( type_qualifier )* declarator )=> type_id );", 13, 0, self.input)
+
+                    raise nvae
+
+                if alt13 == 1:
+                    # C.g:154:4: 'void'
+                    self.match(self.input, 34, self.FOLLOW_34_in_type_specifier366)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 2:
+                    # C.g:155:4: 'char'
+                    self.match(self.input, 35, self.FOLLOW_35_in_type_specifier371)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 3:
+                    # C.g:156:4: 'short'
+                    self.match(self.input, 36, self.FOLLOW_36_in_type_specifier376)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 4:
+                    # C.g:157:4: 'int'
+                    self.match(self.input, 37, self.FOLLOW_37_in_type_specifier381)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 5:
+                    # C.g:158:4: 'long'
+                    self.match(self.input, 38, self.FOLLOW_38_in_type_specifier386)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 6:
+                    # C.g:159:4: 'float'
+                    self.match(self.input, 39, self.FOLLOW_39_in_type_specifier391)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 7:
+                    # C.g:160:4: 'double'
+                    self.match(self.input, 40, self.FOLLOW_40_in_type_specifier396)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 8:
+                    # C.g:161:4: 'signed'
+                    self.match(self.input, 41, self.FOLLOW_41_in_type_specifier401)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 9:
+                    # C.g:162:4: 'unsigned'
+                    self.match(self.input, 42, self.FOLLOW_42_in_type_specifier406)
+                    if self.failed:
+                        return
+
+
+                elif alt13 == 10:
+                    # C.g:163:4: s= struct_or_union_specifier
+                    self.following.append(self.FOLLOW_struct_or_union_specifier_in_type_specifier413)
+                    s = self.struct_or_union_specifier()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    if self.backtracking == 0:
+\r
+                        if s.stop != None:\r
+                          self.StoreStructUnionDefinition(s.start.line, s.start.charPositionInLine, s.stop.line, s.stop.charPositionInLine, self.input.toString(s.start,s.stop))\r
+
+
+
+
+                elif alt13 == 11:
+                    # C.g:168:4: e= enum_specifier
+                    self.following.append(self.FOLLOW_enum_specifier_in_type_specifier423)
+                    e = self.enum_specifier()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    if self.backtracking == 0:
+\r
+                        if e.stop != None:\r
+                          self.StoreEnumerationDefinition(e.start.line, e.start.charPositionInLine, e.stop.line, e.stop.charPositionInLine, self.input.toString(e.start,e.stop))\r
+
+
+
+
+                elif alt13 == 12:
+                    # C.g:173:4: ( IDENTIFIER ( type_qualifier )* declarator )=> type_id
+                    self.following.append(self.FOLLOW_type_id_in_type_specifier441)
+                    self.type_id()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 9, type_specifier_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end type_specifier
+
+
+    # $ANTLR start type_id
+    # C.g:176:1: type_id : IDENTIFIER ;
+    def type_id(self, ):
+
+        type_id_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 10):
+                    return
+
+                # C.g:177:5: ( IDENTIFIER )
+                # C.g:177:9: IDENTIFIER
+                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_type_id457)
+                if self.failed:
+                    return
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 10, type_id_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end type_id
+
+    class struct_or_union_specifier_return(object):
+        def __init__(self):
+            self.start = None
+            self.stop = None
+
+
+
+    # $ANTLR start struct_or_union_specifier
+    # C.g:181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );
+    def struct_or_union_specifier(self, ):
+
+        retval = self.struct_or_union_specifier_return()
+        retval.start = self.input.LT(1)
+        struct_or_union_specifier_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 11):
+                    return retval
+
+                # C.g:183:2: ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER )
+                alt15 = 2
+                LA15_0 = self.input.LA(1)
+
+                if ((45 <= LA15_0 <= 46)) :
+                    LA15_1 = self.input.LA(2)
+
+                    if (LA15_1 == IDENTIFIER) :
+                        LA15_2 = self.input.LA(3)
+
+                        if (LA15_2 == EOF or LA15_2 == IDENTIFIER or LA15_2 == 25 or LA15_2 == 27 or (29 <= LA15_2 <= 42) or (45 <= LA15_2 <= 63) or LA15_2 == 65) :
+                            alt15 = 2
+                        elif (LA15_2 == 43) :
+                            alt15 = 1
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return retval
+
+                            nvae = NoViableAltException("181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 2, self.input)
+
+                            raise nvae
+
+                    elif (LA15_1 == 43) :
+                        alt15 = 1
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return retval
+
+                        nvae = NoViableAltException("181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 1, self.input)
+
+                        raise nvae
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return retval
+
+                    nvae = NoViableAltException("181:1: struct_or_union_specifier options {k=3; } : ( struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}' | struct_or_union IDENTIFIER );", 15, 0, self.input)
+
+                    raise nvae
+
+                if alt15 == 1:
+                    # C.g:183:4: struct_or_union ( IDENTIFIER )? '{' struct_declaration_list '}'
+                    self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier484)
+                    self.struct_or_union()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+                    # C.g:183:20: ( IDENTIFIER )?
+                    alt14 = 2
+                    LA14_0 = self.input.LA(1)
+
+                    if (LA14_0 == IDENTIFIER) :
+                        alt14 = 1
+                    if alt14 == 1:
+                        # C.g:0:0: IDENTIFIER
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier486)
+                        if self.failed:
+                            return retval
+
+
+
+                    self.match(self.input, 43, self.FOLLOW_43_in_struct_or_union_specifier489)
+                    if self.failed:
+                        return retval
+                    self.following.append(self.FOLLOW_struct_declaration_list_in_struct_or_union_specifier491)
+                    self.struct_declaration_list()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+                    self.match(self.input, 44, self.FOLLOW_44_in_struct_or_union_specifier493)
+                    if self.failed:
+                        return retval
+
+
+                elif alt15 == 2:
+                    # C.g:184:4: struct_or_union IDENTIFIER
+                    self.following.append(self.FOLLOW_struct_or_union_in_struct_or_union_specifier498)
+                    self.struct_or_union()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_struct_or_union_specifier500)
+                    if self.failed:
+                        return retval
+
+
+                retval.stop = self.input.LT(-1)
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 11, struct_or_union_specifier_StartIndex)
+
+            pass
+
+        return retval
+
+    # $ANTLR end struct_or_union_specifier
+
+
+    # $ANTLR start struct_or_union
+    # C.g:187:1: struct_or_union : ( 'struct' | 'union' );
+    def struct_or_union(self, ):
+
+        struct_or_union_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 12):
+                    return
+
+                # C.g:188:2: ( 'struct' | 'union' )
+                # C.g:
+                if (45 <= self.input.LA(1) <= 46):
+                    self.input.consume();
+                    self.errorRecovery = False
+                    self.failed = False
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    mse = MismatchedSetException(None, self.input)
+                    self.recoverFromMismatchedSet(
+                        self.input, mse, self.FOLLOW_set_in_struct_or_union0
+                        )
+                    raise mse
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 12, struct_or_union_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end struct_or_union
+
+
+    # $ANTLR start struct_declaration_list
+    # C.g:192:1: struct_declaration_list : ( struct_declaration )+ ;
+    def struct_declaration_list(self, ):
+
+        struct_declaration_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 13):
+                    return
+
+                # C.g:193:2: ( ( struct_declaration )+ )
+                # C.g:193:4: ( struct_declaration )+
+                # C.g:193:4: ( struct_declaration )+
+                cnt16 = 0
+                while True: #loop16
+                    alt16 = 2
+                    LA16_0 = self.input.LA(1)
+
+                    if (LA16_0 == IDENTIFIER or (34 <= LA16_0 <= 42) or (45 <= LA16_0 <= 46) or (48 <= LA16_0 <= 60)) :
+                        alt16 = 1
+
+
+                    if alt16 == 1:
+                        # C.g:0:0: struct_declaration
+                        self.following.append(self.FOLLOW_struct_declaration_in_struct_declaration_list527)
+                        self.struct_declaration()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    else:
+                        if cnt16 >= 1:
+                            break #loop16
+
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        eee = EarlyExitException(16, self.input)
+                        raise eee
+
+                    cnt16 += 1
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 13, struct_declaration_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end struct_declaration_list
+
+
+    # $ANTLR start struct_declaration
+    # C.g:196:1: struct_declaration : specifier_qualifier_list struct_declarator_list ';' ;
+    def struct_declaration(self, ):
+
+        struct_declaration_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 14):
+                    return
+
+                # C.g:197:2: ( specifier_qualifier_list struct_declarator_list ';' )
+                # C.g:197:4: specifier_qualifier_list struct_declarator_list ';'
+                self.following.append(self.FOLLOW_specifier_qualifier_list_in_struct_declaration539)
+                self.specifier_qualifier_list()
+                self.following.pop()
+                if self.failed:
+                    return
+                self.following.append(self.FOLLOW_struct_declarator_list_in_struct_declaration541)
+                self.struct_declarator_list()
+                self.following.pop()
+                if self.failed:
+                    return
+                self.match(self.input, 25, self.FOLLOW_25_in_struct_declaration543)
+                if self.failed:
+                    return
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 14, struct_declaration_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end struct_declaration
+
+
+    # $ANTLR start specifier_qualifier_list
+    # C.g:200:1: specifier_qualifier_list : ( type_qualifier | type_specifier )+ ;
+    def specifier_qualifier_list(self, ):
+
+        specifier_qualifier_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 15):
+                    return
+
+                # C.g:201:2: ( ( type_qualifier | type_specifier )+ )
+                # C.g:201:4: ( type_qualifier | type_specifier )+
+                # C.g:201:4: ( type_qualifier | type_specifier )+
+                cnt17 = 0
+                while True: #loop17
+                    alt17 = 3
+                    LA17 = self.input.LA(1)
+                    if LA17 == 58:
+                        LA17_2 = self.input.LA(2)
+
+                        if (self.synpred39()) :
+                            alt17 = 1
+
+
+                    elif LA17 == 59:
+                        LA17_3 = self.input.LA(2)
+
+                        if (self.synpred39()) :
+                            alt17 = 1
+
+
+                    elif LA17 == 60:
+                        LA17_4 = self.input.LA(2)
+
+                        if (self.synpred39()) :
+                            alt17 = 1
+
+
+                    elif LA17 == IDENTIFIER:
+                        LA17 = self.input.LA(2)
+                        if LA17 == EOF or LA17 == IDENTIFIER or LA17 == 34 or LA17 == 35 or LA17 == 36 or LA17 == 37 or LA17 == 38 or LA17 == 39 or LA17 == 40 or LA17 == 41 or LA17 == 42 or LA17 == 45 or LA17 == 46 or LA17 == 48 or LA17 == 49 or LA17 == 50 or LA17 == 51 or LA17 == 52 or LA17 == 53 or LA17 == 54 or LA17 == 55 or LA17 == 56 or LA17 == 57 or LA17 == 58 or LA17 == 59 or LA17 == 60 or LA17 == 62 or LA17 == 65:
+                            alt17 = 2
+                        elif LA17 == 61:
+                            LA17_94 = self.input.LA(3)
+
+                            if (self.synpred40()) :
+                                alt17 = 2
+
+
+                        elif LA17 == 47:
+                            LA17_95 = self.input.LA(3)
+
+                            if (self.synpred40()) :
+                                alt17 = 2
+
+
+                        elif LA17 == 63:
+                            LA17_96 = self.input.LA(3)
+
+                            if (self.synpred40()) :
+                                alt17 = 2
+
+
+
+                    elif LA17 == 49 or LA17 == 50 or LA17 == 51 or LA17 == 52 or LA17 == 53 or LA17 == 54 or LA17 == 55 or LA17 == 56 or LA17 == 57:
+                        alt17 = 1
+                    elif LA17 == 34 or LA17 == 35 or LA17 == 36 or LA17 == 37 or LA17 == 38 or LA17 == 39 or LA17 == 40 or LA17 == 41 or LA17 == 42 or LA17 == 45 or LA17 == 46 or LA17 == 48:
+                        alt17 = 2
+
+                    if alt17 == 1:
+                        # C.g:201:6: type_qualifier
+                        self.following.append(self.FOLLOW_type_qualifier_in_specifier_qualifier_list556)
+                        self.type_qualifier()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    elif alt17 == 2:
+                        # C.g:201:23: type_specifier
+                        self.following.append(self.FOLLOW_type_specifier_in_specifier_qualifier_list560)
+                        self.type_specifier()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    else:
+                        if cnt17 >= 1:
+                            break #loop17
+
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        eee = EarlyExitException(17, self.input)
+                        raise eee
+
+                    cnt17 += 1
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 15, specifier_qualifier_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end specifier_qualifier_list
+
+
+    # $ANTLR start struct_declarator_list
+    # C.g:204:1: struct_declarator_list : struct_declarator ( ',' struct_declarator )* ;
+    def struct_declarator_list(self, ):
+
+        struct_declarator_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 16):
+                    return
+
+                # C.g:205:2: ( struct_declarator ( ',' struct_declarator )* )
+                # C.g:205:4: struct_declarator ( ',' struct_declarator )*
+                self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list574)
+                self.struct_declarator()
+                self.following.pop()
+                if self.failed:
+                    return
+                # C.g:205:22: ( ',' struct_declarator )*
+                while True: #loop18
+                    alt18 = 2
+                    LA18_0 = self.input.LA(1)
+
+                    if (LA18_0 == 27) :
+                        alt18 = 1
+
+
+                    if alt18 == 1:
+                        # C.g:205:23: ',' struct_declarator
+                        self.match(self.input, 27, self.FOLLOW_27_in_struct_declarator_list577)
+                        if self.failed:
+                            return
+                        self.following.append(self.FOLLOW_struct_declarator_in_struct_declarator_list579)
+                        self.struct_declarator()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    else:
+                        break #loop18
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 16, struct_declarator_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end struct_declarator_list
+
+
+    # $ANTLR start struct_declarator
+    # C.g:208:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );
+    def struct_declarator(self, ):
+
+        struct_declarator_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 17):
+                    return
+
+                # C.g:209:2: ( declarator ( ':' constant_expression )? | ':' constant_expression )
+                alt20 = 2
+                LA20_0 = self.input.LA(1)
+
+                if (LA20_0 == IDENTIFIER or (58 <= LA20_0 <= 61) or LA20_0 == 65) :
+                    alt20 = 1
+                elif (LA20_0 == 47) :
+                    alt20 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("208:1: struct_declarator : ( declarator ( ':' constant_expression )? | ':' constant_expression );", 20, 0, self.input)
+
+                    raise nvae
+
+                if alt20 == 1:
+                    # C.g:209:4: declarator ( ':' constant_expression )?
+                    self.following.append(self.FOLLOW_declarator_in_struct_declarator592)
+                    self.declarator()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    # C.g:209:15: ( ':' constant_expression )?
+                    alt19 = 2
+                    LA19_0 = self.input.LA(1)
+
+                    if (LA19_0 == 47) :
+                        alt19 = 1
+                    if alt19 == 1:
+                        # C.g:209:16: ':' constant_expression
+                        self.match(self.input, 47, self.FOLLOW_47_in_struct_declarator595)
+                        if self.failed:
+                            return
+                        self.following.append(self.FOLLOW_constant_expression_in_struct_declarator597)
+                        self.constant_expression()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+
+
+
+                elif alt20 == 2:
+                    # C.g:210:4: ':' constant_expression
+                    self.match(self.input, 47, self.FOLLOW_47_in_struct_declarator604)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_constant_expression_in_struct_declarator606)
+                    self.constant_expression()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 17, struct_declarator_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end struct_declarator
+
+    class enum_specifier_return(object):
+        def __init__(self):
+            self.start = None
+            self.stop = None
+
+
+
+    # $ANTLR start enum_specifier
+    # C.g:213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );
+    def enum_specifier(self, ):
+
+        retval = self.enum_specifier_return()
+        retval.start = self.input.LT(1)
+        enum_specifier_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 18):
+                    return retval
+
+                # C.g:215:2: ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER )
+                alt23 = 3
+                LA23_0 = self.input.LA(1)
+
+                if (LA23_0 == 48) :
+                    LA23_1 = self.input.LA(2)
+
+                    if (LA23_1 == IDENTIFIER) :
+                        LA23_2 = self.input.LA(3)
+
+                        if (LA23_2 == 43) :
+                            alt23 = 2
+                        elif (LA23_2 == EOF or LA23_2 == IDENTIFIER or LA23_2 == 25 or LA23_2 == 27 or (29 <= LA23_2 <= 42) or (45 <= LA23_2 <= 63) or LA23_2 == 65) :
+                            alt23 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return retval
+
+                            nvae = NoViableAltException("213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );", 23, 2, self.input)
+
+                            raise nvae
+
+                    elif (LA23_1 == 43) :
+                        alt23 = 1
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return retval
+
+                        nvae = NoViableAltException("213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );", 23, 1, self.input)
+
+                        raise nvae
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return retval
+
+                    nvae = NoViableAltException("213:1: enum_specifier options {k=3; } : ( 'enum' '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}' | 'enum' IDENTIFIER );", 23, 0, self.input)
+
+                    raise nvae
+
+                if alt23 == 1:
+                    # C.g:215:4: 'enum' '{' enumerator_list ( ',' )? '}'
+                    self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier624)
+                    if self.failed:
+                        return retval
+                    self.match(self.input, 43, self.FOLLOW_43_in_enum_specifier626)
+                    if self.failed:
+                        return retval
+                    self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier628)
+                    self.enumerator_list()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+                    # C.g:215:31: ( ',' )?
+                    alt21 = 2
+                    LA21_0 = self.input.LA(1)
+
+                    if (LA21_0 == 27) :
+                        alt21 = 1
+                    if alt21 == 1:
+                        # C.g:0:0: ','
+                        self.match(self.input, 27, self.FOLLOW_27_in_enum_specifier630)
+                        if self.failed:
+                            return retval
+
+
+
+                    self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier633)
+                    if self.failed:
+                        return retval
+
+
+                elif alt23 == 2:
+                    # C.g:216:4: 'enum' IDENTIFIER '{' enumerator_list ( ',' )? '}'
+                    self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier638)
+                    if self.failed:
+                        return retval
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier640)
+                    if self.failed:
+                        return retval
+                    self.match(self.input, 43, self.FOLLOW_43_in_enum_specifier642)
+                    if self.failed:
+                        return retval
+                    self.following.append(self.FOLLOW_enumerator_list_in_enum_specifier644)
+                    self.enumerator_list()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+                    # C.g:216:42: ( ',' )?
+                    alt22 = 2
+                    LA22_0 = self.input.LA(1)
+
+                    if (LA22_0 == 27) :
+                        alt22 = 1
+                    if alt22 == 1:
+                        # C.g:0:0: ','
+                        self.match(self.input, 27, self.FOLLOW_27_in_enum_specifier646)
+                        if self.failed:
+                            return retval
+
+
+
+                    self.match(self.input, 44, self.FOLLOW_44_in_enum_specifier649)
+                    if self.failed:
+                        return retval
+
+
+                elif alt23 == 3:
+                    # C.g:217:4: 'enum' IDENTIFIER
+                    self.match(self.input, 48, self.FOLLOW_48_in_enum_specifier654)
+                    if self.failed:
+                        return retval
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enum_specifier656)
+                    if self.failed:
+                        return retval
+
+
+                retval.stop = self.input.LT(-1)
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 18, enum_specifier_StartIndex)
+
+            pass
+
+        return retval
+
+    # $ANTLR end enum_specifier
+
+
+    # $ANTLR start enumerator_list
+    # C.g:220:1: enumerator_list : enumerator ( ',' enumerator )* ;
+    def enumerator_list(self, ):
+
+        enumerator_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 19):
+                    return
+
+                # C.g:221:2: ( enumerator ( ',' enumerator )* )
+                # C.g:221:4: enumerator ( ',' enumerator )*
+                self.following.append(self.FOLLOW_enumerator_in_enumerator_list667)
+                self.enumerator()
+                self.following.pop()
+                if self.failed:
+                    return
+                # C.g:221:15: ( ',' enumerator )*
+                while True: #loop24
+                    alt24 = 2
+                    LA24_0 = self.input.LA(1)
+
+                    if (LA24_0 == 27) :
+                        LA24_1 = self.input.LA(2)
+
+                        if (LA24_1 == IDENTIFIER) :
+                            alt24 = 1
+
+
+
+
+                    if alt24 == 1:
+                        # C.g:221:16: ',' enumerator
+                        self.match(self.input, 27, self.FOLLOW_27_in_enumerator_list670)
+                        if self.failed:
+                            return
+                        self.following.append(self.FOLLOW_enumerator_in_enumerator_list672)
+                        self.enumerator()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    else:
+                        break #loop24
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 19, enumerator_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end enumerator_list
+
+
+    # $ANTLR start enumerator
+    # C.g:224:1: enumerator : IDENTIFIER ( '=' constant_expression )? ;
+    def enumerator(self, ):
+
+        enumerator_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 20):
+                    return
+
+                # C.g:225:2: ( IDENTIFIER ( '=' constant_expression )? )
+                # C.g:225:4: IDENTIFIER ( '=' constant_expression )?
+                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_enumerator685)
+                if self.failed:
+                    return
+                # C.g:225:15: ( '=' constant_expression )?
+                alt25 = 2
+                LA25_0 = self.input.LA(1)
+
+                if (LA25_0 == 28) :
+                    alt25 = 1
+                if alt25 == 1:
+                    # C.g:225:16: '=' constant_expression
+                    self.match(self.input, 28, self.FOLLOW_28_in_enumerator688)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_constant_expression_in_enumerator690)
+                    self.constant_expression()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 20, enumerator_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end enumerator
+
+
+    # $ANTLR start type_qualifier
+    # C.g:228:1: type_qualifier : ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' | 'CONST' | 'UNALIGNED' | 'VOLATILE' | 'GLOBAL_REMOVE_IF_UNREFERENCED' | 'EFIAPI' | 'EFI_BOOTSERVICE' | 'EFI_RUNTIMESERVICE' );
+    def type_qualifier(self, ):
+
+        type_qualifier_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 21):
+                    return
+
+                # C.g:229:2: ( 'const' | 'volatile' | 'IN' | 'OUT' | 'OPTIONAL' | 'CONST' | 'UNALIGNED' | 'VOLATILE' | 'GLOBAL_REMOVE_IF_UNREFERENCED' | 'EFIAPI' | 'EFI_BOOTSERVICE' | 'EFI_RUNTIMESERVICE' )
+                # C.g:
+                if (49 <= self.input.LA(1) <= 60):
+                    self.input.consume();
+                    self.errorRecovery = False
+                    self.failed = False
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    mse = MismatchedSetException(None, self.input)
+                    self.recoverFromMismatchedSet(
+                        self.input, mse, self.FOLLOW_set_in_type_qualifier0
+                        )
+                    raise mse
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 21, type_qualifier_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end type_qualifier
+
+    class declarator_return(object):
+        def __init__(self):
+            self.start = None
+            self.stop = None
+
+
+
+    # $ANTLR start declarator
+    # C.g:243:1: declarator : ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer );
+    def declarator(self, ):
+
+        retval = self.declarator_return()
+        retval.start = self.input.LT(1)
+        declarator_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 22):
+                    return retval
+
+                # C.g:244:2: ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer )
+                alt30 = 2
+                LA30_0 = self.input.LA(1)
+
+                if (LA30_0 == 65) :
+                    LA30_1 = self.input.LA(2)
+
+                    if (self.synpred65()) :
+                        alt30 = 1
+                    elif (True) :
+                        alt30 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return retval
+
+                        nvae = NoViableAltException("243:1: declarator : ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer );", 30, 1, self.input)
+
+                        raise nvae
+
+                elif (LA30_0 == IDENTIFIER or (58 <= LA30_0 <= 61)) :
+                    alt30 = 1
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return retval
+
+                    nvae = NoViableAltException("243:1: declarator : ( ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator | pointer );", 30, 0, self.input)
+
+                    raise nvae
+
+                if alt30 == 1:
+                    # C.g:244:4: ( pointer )? ( 'EFIAPI' )? ( 'EFI_BOOTSERVICE' )? ( 'EFI_RUNTIMESERVICE' )? direct_declarator
+                    # C.g:244:4: ( pointer )?
+                    alt26 = 2
+                    LA26_0 = self.input.LA(1)
+
+                    if (LA26_0 == 65) :
+                        alt26 = 1
+                    if alt26 == 1:
+                        # C.g:0:0: pointer
+                        self.following.append(self.FOLLOW_pointer_in_declarator769)
+                        self.pointer()
+                        self.following.pop()
+                        if self.failed:
+                            return retval
+
+
+
+                    # C.g:244:13: ( 'EFIAPI' )?
+                    alt27 = 2
+                    LA27_0 = self.input.LA(1)
+
+                    if (LA27_0 == 58) :
+                        alt27 = 1
+                    if alt27 == 1:
+                        # C.g:244:14: 'EFIAPI'
+                        self.match(self.input, 58, self.FOLLOW_58_in_declarator773)
+                        if self.failed:
+                            return retval
+
+
+
+                    # C.g:244:25: ( 'EFI_BOOTSERVICE' )?
+                    alt28 = 2
+                    LA28_0 = self.input.LA(1)
+
+                    if (LA28_0 == 59) :
+                        alt28 = 1
+                    if alt28 == 1:
+                        # C.g:244:26: 'EFI_BOOTSERVICE'
+                        self.match(self.input, 59, self.FOLLOW_59_in_declarator778)
+                        if self.failed:
+                            return retval
+
+
+
+                    # C.g:244:46: ( 'EFI_RUNTIMESERVICE' )?
+                    alt29 = 2
+                    LA29_0 = self.input.LA(1)
+
+                    if (LA29_0 == 60) :
+                        alt29 = 1
+                    if alt29 == 1:
+                        # C.g:244:47: 'EFI_RUNTIMESERVICE'
+                        self.match(self.input, 60, self.FOLLOW_60_in_declarator783)
+                        if self.failed:
+                            return retval
+
+
+
+                    self.following.append(self.FOLLOW_direct_declarator_in_declarator787)
+                    self.direct_declarator()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+
+
+                elif alt30 == 2:
+                    # C.g:246:4: pointer
+                    self.following.append(self.FOLLOW_pointer_in_declarator793)
+                    self.pointer()
+                    self.following.pop()
+                    if self.failed:
+                        return retval
+
+
+                retval.stop = self.input.LT(-1)
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 22, declarator_StartIndex)
+
+            pass
+
+        return retval
+
+    # $ANTLR end declarator
+
+
+    # $ANTLR start direct_declarator
+    # C.g:249:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ );
+    def direct_declarator(self, ):
+
+        direct_declarator_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 23):
+                    return
+
+                # C.g:250:2: ( IDENTIFIER ( declarator_suffix )* | '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ )
+                alt34 = 2
+                LA34_0 = self.input.LA(1)
+
+                if (LA34_0 == IDENTIFIER) :
+                    alt34 = 1
+                elif (LA34_0 == 61) :
+                    alt34 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("249:1: direct_declarator : ( IDENTIFIER ( declarator_suffix )* | '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+ );", 34, 0, self.input)
+
+                    raise nvae
+
+                if alt34 == 1:
+                    # C.g:250:4: IDENTIFIER ( declarator_suffix )*
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_direct_declarator804)
+                    if self.failed:
+                        return
+                    # C.g:250:15: ( declarator_suffix )*
+                    while True: #loop31
+                        alt31 = 2
+                        LA31_0 = self.input.LA(1)
+
+                        if (LA31_0 == 61) :
+                            LA31 = self.input.LA(2)
+                            if LA31 == 62:
+                                LA31_30 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 65:
+                                LA31_31 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 58:
+                                LA31_34 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 59:
+                                LA31_35 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 60:
+                                LA31_36 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == IDENTIFIER:
+                                LA31_37 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 29 or LA31 == 30 or LA31 == 31 or LA31 == 32 or LA31 == 33:
+                                LA31_38 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 34:
+                                LA31_39 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 35:
+                                LA31_40 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 36:
+                                LA31_41 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 37:
+                                LA31_42 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 38:
+                                LA31_43 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 39:
+                                LA31_44 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 40:
+                                LA31_45 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 41:
+                                LA31_46 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 42:
+                                LA31_47 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 45 or LA31 == 46:
+                                LA31_48 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 48:
+                                LA31_49 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 49 or LA31 == 50 or LA31 == 51 or LA31 == 52 or LA31 == 53 or LA31 == 54 or LA31 == 55 or LA31 == 56 or LA31 == 57:
+                                LA31_50 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+
+                        elif (LA31_0 == 63) :
+                            LA31 = self.input.LA(2)
+                            if LA31 == 64:
+                                LA31_51 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 61:
+                                LA31_52 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == IDENTIFIER:
+                                LA31_53 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == HEX_LITERAL:
+                                LA31_54 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == OCTAL_LITERAL:
+                                LA31_55 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == DECIMAL_LITERAL:
+                                LA31_56 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == CHARACTER_LITERAL:
+                                LA31_57 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == STRING_LITERAL:
+                                LA31_58 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == FLOATING_POINT_LITERAL:
+                                LA31_59 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 71:
+                                LA31_60 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 72:
+                                LA31_61 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 65 or LA31 == 67 or LA31 == 68 or LA31 == 76 or LA31 == 77 or LA31 == 78:
+                                LA31_62 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+                            elif LA31 == 73:
+                                LA31_63 = self.input.LA(3)
+
+                                if (self.synpred66()) :
+                                    alt31 = 1
+
+
+
+
+
+                        if alt31 == 1:
+                            # C.g:0:0: declarator_suffix
+                            self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator806)
+                            self.declarator_suffix()
+                            self.following.pop()
+                            if self.failed:
+                                return
+
+
+                        else:
+                            break #loop31
+
+
+
+
+                elif alt34 == 2:
+                    # C.g:251:4: '(' ( 'EFIAPI' )? declarator ')' ( declarator_suffix )+
+                    self.match(self.input, 61, self.FOLLOW_61_in_direct_declarator812)
+                    if self.failed:
+                        return
+                    # C.g:251:8: ( 'EFIAPI' )?
+                    alt32 = 2
+                    LA32_0 = self.input.LA(1)
+
+                    if (LA32_0 == 58) :
+                        LA32_1 = self.input.LA(2)
+
+                        if (self.synpred68()) :
+                            alt32 = 1
+                    if alt32 == 1:
+                        # C.g:251:9: 'EFIAPI'
+                        self.match(self.input, 58, self.FOLLOW_58_in_direct_declarator815)
+                        if self.failed:
+                            return
+
+
+
+                    self.following.append(self.FOLLOW_declarator_in_direct_declarator819)
+                    self.declarator()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    self.match(self.input, 62, self.FOLLOW_62_in_direct_declarator821)
+                    if self.failed:
+                        return
+                    # C.g:251:35: ( declarator_suffix )+
+                    cnt33 = 0
+                    while True: #loop33
+                        alt33 = 2
+                        LA33_0 = self.input.LA(1)
+
+                        if (LA33_0 == 61) :
+                            LA33 = self.input.LA(2)
+                            if LA33 == 62:
+                                LA33_30 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 65:
+                                LA33_31 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 58:
+                                LA33_34 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 59:
+                                LA33_35 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 60:
+                                LA33_36 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == IDENTIFIER:
+                                LA33_37 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 29 or LA33 == 30 or LA33 == 31 or LA33 == 32 or LA33 == 33:
+                                LA33_38 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 34:
+                                LA33_39 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 35:
+                                LA33_40 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 36:
+                                LA33_41 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 37:
+                                LA33_42 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 38:
+                                LA33_43 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 39:
+                                LA33_44 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 40:
+                                LA33_45 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 41:
+                                LA33_46 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 42:
+                                LA33_47 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 45 or LA33 == 46:
+                                LA33_48 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 48:
+                                LA33_49 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 49 or LA33 == 50 or LA33 == 51 or LA33 == 52 or LA33 == 53 or LA33 == 54 or LA33 == 55 or LA33 == 56 or LA33 == 57:
+                                LA33_50 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+
+                        elif (LA33_0 == 63) :
+                            LA33 = self.input.LA(2)
+                            if LA33 == 64:
+                                LA33_51 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 61:
+                                LA33_52 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == IDENTIFIER:
+                                LA33_53 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == HEX_LITERAL:
+                                LA33_54 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == OCTAL_LITERAL:
+                                LA33_55 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == DECIMAL_LITERAL:
+                                LA33_56 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == CHARACTER_LITERAL:
+                                LA33_57 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == STRING_LITERAL:
+                                LA33_58 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == FLOATING_POINT_LITERAL:
+                                LA33_59 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 71:
+                                LA33_60 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 72:
+                                LA33_61 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 65 or LA33 == 67 or LA33 == 68 or LA33 == 76 or LA33 == 77 or LA33 == 78:
+                                LA33_62 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+                            elif LA33 == 73:
+                                LA33_63 = self.input.LA(3)
+
+                                if (self.synpred69()) :
+                                    alt33 = 1
+
+
+
+
+
+                        if alt33 == 1:
+                            # C.g:0:0: declarator_suffix
+                            self.following.append(self.FOLLOW_declarator_suffix_in_direct_declarator823)
+                            self.declarator_suffix()
+                            self.following.pop()
+                            if self.failed:
+                                return
+
+
+                        else:
+                            if cnt33 >= 1:
+                                break #loop33
+
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            eee = EarlyExitException(33, self.input)
+                            raise eee
+
+                        cnt33 += 1
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 23, direct_declarator_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end direct_declarator
+
+
+    # $ANTLR start declarator_suffix
+    # C.g:254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );
+    def declarator_suffix(self, ):
+
+        declarator_suffix_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 24):
+                    return
+
+                # C.g:255:2: ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' )
+                alt35 = 5
+                LA35_0 = self.input.LA(1)
+
+                if (LA35_0 == 63) :
+                    LA35_1 = self.input.LA(2)
+
+                    if (LA35_1 == 64) :
+                        alt35 = 2
+                    elif ((IDENTIFIER <= LA35_1 <= FLOATING_POINT_LITERAL) or LA35_1 == 61 or LA35_1 == 65 or (67 <= LA35_1 <= 68) or (71 <= LA35_1 <= 73) or (76 <= LA35_1 <= 78)) :
+                        alt35 = 1
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 1, self.input)
+
+                        raise nvae
+
+                elif (LA35_0 == 61) :
+                    LA35 = self.input.LA(2)
+                    if LA35 == 62:
+                        alt35 = 5
+                    elif LA35 == IDENTIFIER:
+                        LA35_17 = self.input.LA(3)
+
+                        if (self.synpred72()) :
+                            alt35 = 3
+                        elif (self.synpred73()) :
+                            alt35 = 4
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 17, self.input)
+
+                            raise nvae
+
+                    elif LA35 == 29 or LA35 == 30 or LA35 == 31 or LA35 == 32 or LA35 == 33 or LA35 == 34 or LA35 == 35 or LA35 == 36 or LA35 == 37 or LA35 == 38 or LA35 == 39 or LA35 == 40 or LA35 == 41 or LA35 == 42 or LA35 == 45 or LA35 == 46 or LA35 == 48 or LA35 == 49 or LA35 == 50 or LA35 == 51 or LA35 == 52 or LA35 == 53 or LA35 == 54 or LA35 == 55 or LA35 == 56 or LA35 == 57 or LA35 == 58 or LA35 == 59 or LA35 == 60 or LA35 == 65:
+                        alt35 = 3
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 2, self.input)
+
+                        raise nvae
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("254:1: declarator_suffix : ( '[' constant_expression ']' | '[' ']' | '(' parameter_type_list ')' | '(' identifier_list ')' | '(' ')' );", 35, 0, self.input)
+
+                    raise nvae
+
+                if alt35 == 1:
+                    # C.g:255:6: '[' constant_expression ']'
+                    self.match(self.input, 63, self.FOLLOW_63_in_declarator_suffix837)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_constant_expression_in_declarator_suffix839)
+                    self.constant_expression()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    self.match(self.input, 64, self.FOLLOW_64_in_declarator_suffix841)
+                    if self.failed:
+                        return
+
+
+                elif alt35 == 2:
+                    # C.g:256:9: '[' ']'
+                    self.match(self.input, 63, self.FOLLOW_63_in_declarator_suffix851)
+                    if self.failed:
+                        return
+                    self.match(self.input, 64, self.FOLLOW_64_in_declarator_suffix853)
+                    if self.failed:
+                        return
+
+
+                elif alt35 == 3:
+                    # C.g:257:9: '(' parameter_type_list ')'
+                    self.match(self.input, 61, self.FOLLOW_61_in_declarator_suffix863)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_parameter_type_list_in_declarator_suffix865)
+                    self.parameter_type_list()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    self.match(self.input, 62, self.FOLLOW_62_in_declarator_suffix867)
+                    if self.failed:
+                        return
+
+
+                elif alt35 == 4:
+                    # C.g:258:9: '(' identifier_list ')'
+                    self.match(self.input, 61, self.FOLLOW_61_in_declarator_suffix877)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_identifier_list_in_declarator_suffix879)
+                    self.identifier_list()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    self.match(self.input, 62, self.FOLLOW_62_in_declarator_suffix881)
+                    if self.failed:
+                        return
+
+
+                elif alt35 == 5:
+                    # C.g:259:9: '(' ')'
+                    self.match(self.input, 61, self.FOLLOW_61_in_declarator_suffix891)
+                    if self.failed:
+                        return
+                    self.match(self.input, 62, self.FOLLOW_62_in_declarator_suffix893)
+                    if self.failed:
+                        return
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 24, declarator_suffix_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end declarator_suffix
+
+
+    # $ANTLR start pointer
+    # C.g:262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );
+    def pointer(self, ):
+
+        pointer_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 25):
+                    return
+
+                # C.g:263:2: ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' )
+                alt38 = 3
+                LA38_0 = self.input.LA(1)
+
+                if (LA38_0 == 65) :
+                    LA38 = self.input.LA(2)
+                    if LA38 == 58:
+                        LA38_2 = self.input.LA(3)
+
+                        if (self.synpred76()) :
+                            alt38 = 1
+                        elif (True) :
+                            alt38 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 2, self.input)
+
+                            raise nvae
+
+                    elif LA38 == 65:
+                        LA38_3 = self.input.LA(3)
+
+                        if (self.synpred77()) :
+                            alt38 = 2
+                        elif (True) :
+                            alt38 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 3, self.input)
+
+                            raise nvae
+
+                    elif LA38 == 59:
+                        LA38_4 = self.input.LA(3)
+
+                        if (self.synpred76()) :
+                            alt38 = 1
+                        elif (True) :
+                            alt38 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 4, self.input)
+
+                            raise nvae
+
+                    elif LA38 == 60:
+                        LA38_5 = self.input.LA(3)
+
+                        if (self.synpred76()) :
+                            alt38 = 1
+                        elif (True) :
+                            alt38 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 5, self.input)
+
+                            raise nvae
+
+                    elif LA38 == 53:
+                        LA38_6 = self.input.LA(3)
+
+                        if (self.synpred76()) :
+                            alt38 = 1
+                        elif (True) :
+                            alt38 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 6, self.input)
+
+                            raise nvae
+
+                    elif LA38 == EOF or LA38 == IDENTIFIER or LA38 == 25 or LA38 == 26 or LA38 == 27 or LA38 == 28 or LA38 == 29 or LA38 == 30 or LA38 == 31 or LA38 == 32 or LA38 == 33 or LA38 == 34 or LA38 == 35 or LA38 == 36 or LA38 == 37 or LA38 == 38 or LA38 == 39 or LA38 == 40 or LA38 == 41 or LA38 == 42 or LA38 == 43 or LA38 == 45 or LA38 == 46 or LA38 == 47 or LA38 == 48 or LA38 == 61 or LA38 == 62 or LA38 == 63:
+                        alt38 = 3
+                    elif LA38 == 49 or LA38 == 50 or LA38 == 51 or LA38 == 52 or LA38 == 54 or LA38 == 55 or LA38 == 56 or LA38 == 57:
+                        LA38_29 = self.input.LA(3)
+
+                        if (self.synpred76()) :
+                            alt38 = 1
+                        elif (True) :
+                            alt38 = 3
+                        else:
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 29, self.input)
+
+                            raise nvae
+
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 1, self.input)
+
+                        raise nvae
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("262:1: pointer : ( '*' ( type_qualifier )+ ( pointer )? | '*' pointer | '*' );", 38, 0, self.input)
+
+                    raise nvae
+
+                if alt38 == 1:
+                    # C.g:263:4: '*' ( type_qualifier )+ ( pointer )?
+                    self.match(self.input, 65, self.FOLLOW_65_in_pointer904)
+                    if self.failed:
+                        return
+                    # C.g:263:8: ( type_qualifier )+
+                    cnt36 = 0
+                    while True: #loop36
+                        alt36 = 2
+                        LA36 = self.input.LA(1)
+                        if LA36 == 58:
+                            LA36_2 = self.input.LA(2)
+
+                            if (self.synpred74()) :
+                                alt36 = 1
+
+
+                        elif LA36 == 59:
+                            LA36_3 = self.input.LA(2)
+
+                            if (self.synpred74()) :
+                                alt36 = 1
+
+
+                        elif LA36 == 60:
+                            LA36_4 = self.input.LA(2)
+
+                            if (self.synpred74()) :
+                                alt36 = 1
+
+
+                        elif LA36 == 53:
+                            LA36_20 = self.input.LA(2)
+
+                            if (self.synpred74()) :
+                                alt36 = 1
+
+
+                        elif LA36 == 49 or LA36 == 50 or LA36 == 51 or LA36 == 52 or LA36 == 54 or LA36 == 55 or LA36 == 56 or LA36 == 57:
+                            LA36_28 = self.input.LA(2)
+
+                            if (self.synpred74()) :
+                                alt36 = 1
+
+
+
+                        if alt36 == 1:
+                            # C.g:0:0: type_qualifier
+                            self.following.append(self.FOLLOW_type_qualifier_in_pointer906)
+                            self.type_qualifier()
+                            self.following.pop()
+                            if self.failed:
+                                return
+
+
+                        else:
+                            if cnt36 >= 1:
+                                break #loop36
+
+                            if self.backtracking > 0:
+                                self.failed = True
+                                return
+
+                            eee = EarlyExitException(36, self.input)
+                            raise eee
+
+                        cnt36 += 1
+
+
+                    # C.g:263:24: ( pointer )?
+                    alt37 = 2
+                    LA37_0 = self.input.LA(1)
+
+                    if (LA37_0 == 65) :
+                        LA37_1 = self.input.LA(2)
+
+                        if (self.synpred75()) :
+                            alt37 = 1
+                    if alt37 == 1:
+                        # C.g:0:0: pointer
+                        self.following.append(self.FOLLOW_pointer_in_pointer909)
+                        self.pointer()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+
+
+
+                elif alt38 == 2:
+                    # C.g:264:4: '*' pointer
+                    self.match(self.input, 65, self.FOLLOW_65_in_pointer915)
+                    if self.failed:
+                        return
+                    self.following.append(self.FOLLOW_pointer_in_pointer917)
+                    self.pointer()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+                elif alt38 == 3:
+                    # C.g:265:4: '*'
+                    self.match(self.input, 65, self.FOLLOW_65_in_pointer922)
+                    if self.failed:
+                        return
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 25, pointer_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end pointer
+
+
+    # $ANTLR start parameter_type_list
+    # C.g:268:1: parameter_type_list : parameter_list ( ',' ( 'OPTIONAL' )? '...' )? ;
+    def parameter_type_list(self, ):
+
+        parameter_type_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 26):
+                    return
+
+                # C.g:269:2: ( parameter_list ( ',' ( 'OPTIONAL' )? '...' )? )
+                # C.g:269:4: parameter_list ( ',' ( 'OPTIONAL' )? '...' )?
+                self.following.append(self.FOLLOW_parameter_list_in_parameter_type_list933)
+                self.parameter_list()
+                self.following.pop()
+                if self.failed:
+                    return
+                # C.g:269:19: ( ',' ( 'OPTIONAL' )? '...' )?
+                alt40 = 2
+                LA40_0 = self.input.LA(1)
+
+                if (LA40_0 == 27) :
+                    alt40 = 1
+                if alt40 == 1:
+                    # C.g:269:20: ',' ( 'OPTIONAL' )? '...'
+                    self.match(self.input, 27, self.FOLLOW_27_in_parameter_type_list936)
+                    if self.failed:
+                        return
+                    # C.g:269:24: ( 'OPTIONAL' )?
+                    alt39 = 2
+                    LA39_0 = self.input.LA(1)
+
+                    if (LA39_0 == 53) :
+                        alt39 = 1
+                    if alt39 == 1:
+                        # C.g:269:25: 'OPTIONAL'
+                        self.match(self.input, 53, self.FOLLOW_53_in_parameter_type_list939)
+                        if self.failed:
+                            return
+
+
+
+                    self.match(self.input, 66, self.FOLLOW_66_in_parameter_type_list943)
+                    if self.failed:
+                        return
+
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 26, parameter_type_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end parameter_type_list
+
+
+    # $ANTLR start parameter_list
+    # C.g:272:1: parameter_list : parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* ;
+    def parameter_list(self, ):
+
+        parameter_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 27):
+                    return
+
+                # C.g:273:2: ( parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )* )
+                # C.g:273:4: parameter_declaration ( ',' ( 'OPTIONAL' )? parameter_declaration )*
+                self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list956)
+                self.parameter_declaration()
+                self.following.pop()
+                if self.failed:
+                    return
+                # C.g:273:26: ( ',' ( 'OPTIONAL' )? parameter_declaration )*
+                while True: #loop42
+                    alt42 = 2
+                    LA42_0 = self.input.LA(1)
+
+                    if (LA42_0 == 27) :
+                        LA42_1 = self.input.LA(2)
+
+                        if (LA42_1 == 53) :
+                            LA42_3 = self.input.LA(3)
+
+                            if (self.synpred81()) :
+                                alt42 = 1
+
+
+                        elif (LA42_1 == IDENTIFIER or (29 <= LA42_1 <= 42) or (45 <= LA42_1 <= 46) or (48 <= LA42_1 <= 52) or (54 <= LA42_1 <= 60) or LA42_1 == 65) :
+                            alt42 = 1
+
+
+
+
+                    if alt42 == 1:
+                        # C.g:273:27: ',' ( 'OPTIONAL' )? parameter_declaration
+                        self.match(self.input, 27, self.FOLLOW_27_in_parameter_list959)
+                        if self.failed:
+                            return
+                        # C.g:273:31: ( 'OPTIONAL' )?
+                        alt41 = 2
+                        LA41_0 = self.input.LA(1)
+
+                        if (LA41_0 == 53) :
+                            LA41_1 = self.input.LA(2)
+
+                            if (self.synpred80()) :
+                                alt41 = 1
+                        if alt41 == 1:
+                            # C.g:273:32: 'OPTIONAL'
+                            self.match(self.input, 53, self.FOLLOW_53_in_parameter_list962)
+                            if self.failed:
+                                return
+
+
+
+                        self.following.append(self.FOLLOW_parameter_declaration_in_parameter_list966)
+                        self.parameter_declaration()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+                    else:
+                        break #loop42
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 27, parameter_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end parameter_list
+
+
+    # $ANTLR start parameter_declaration
+    # C.g:276:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER );
+    def parameter_declaration(self, ):
+
+        parameter_declaration_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 28):
+                    return
+
+                # C.g:277:2: ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER )
+                alt46 = 2
+                LA46 = self.input.LA(1)
+                if LA46 == 29 or LA46 == 30 or LA46 == 31 or LA46 == 32 or LA46 == 33 or LA46 == 34 or LA46 == 35 or LA46 == 36 or LA46 == 37 or LA46 == 38 or LA46 == 39 or LA46 == 40 or LA46 == 41 or LA46 == 42 or LA46 == 45 or LA46 == 46 or LA46 == 48 or LA46 == 49 or LA46 == 50 or LA46 == 51 or LA46 == 52 or LA46 == 53 or LA46 == 54 or LA46 == 55 or LA46 == 56 or LA46 == 57 or LA46 == 58 or LA46 == 59 or LA46 == 60:
+                    alt46 = 1
+                elif LA46 == IDENTIFIER:
+                    LA46_13 = self.input.LA(2)
+
+                    if (self.synpred85()) :
+                        alt46 = 1
+                    elif (True) :
+                        alt46 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("276:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER );", 46, 13, self.input)
+
+                        raise nvae
+
+                elif LA46 == 65:
+                    alt46 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("276:1: parameter_declaration : ( declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )? | ( pointer )* IDENTIFIER );", 46, 0, self.input)
+
+                    raise nvae
+
+                if alt46 == 1:
+                    # C.g:277:4: declaration_specifiers ( declarator | abstract_declarator )* ( 'OPTIONAL' )?
+                    self.following.append(self.FOLLOW_declaration_specifiers_in_parameter_declaration979)
+                    self.declaration_specifiers()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    # C.g:277:27: ( declarator | abstract_declarator )*
+                    while True: #loop43
+                        alt43 = 3
+                        LA43 = self.input.LA(1)
+                        if LA43 == 65:
+                            LA43_5 = self.input.LA(2)
+
+                            if (self.synpred82()) :
+                                alt43 = 1
+                            elif (self.synpred83()) :
+                                alt43 = 2
+
+
+                        elif LA43 == IDENTIFIER or LA43 == 58 or LA43 == 59 or LA43 == 60:
+                            alt43 = 1
+                        elif LA43 == 61:
+                            LA43 = self.input.LA(2)
+                            if LA43 == 29 or LA43 == 30 or LA43 == 31 or LA43 == 32 or LA43 == 33 or LA43 == 34 or LA43 == 35 or LA43 == 36 or LA43 == 37 or LA43 == 38 or LA43 == 39 or LA43 == 40 or LA43 == 41 or LA43 == 42 or LA43 == 45 or LA43 == 46 or LA43 == 48 or LA43 == 49 or LA43 == 50 or LA43 == 51 or LA43 == 52 or LA43 == 53 or LA43 == 54 or LA43 == 55 or LA43 == 56 or LA43 == 57 or LA43 == 62 or LA43 == 63:
+                                alt43 = 2
+                            elif LA43 == 58:
+                                LA43_25 = self.input.LA(3)
+
+                                if (self.synpred82()) :
+                                    alt43 = 1
+                                elif (self.synpred83()) :
+                                    alt43 = 2
+
+
+                            elif LA43 == 65:
+                                LA43_26 = self.input.LA(3)
+
+                                if (self.synpred82()) :
+                                    alt43 = 1
+                                elif (self.synpred83()) :
+                                    alt43 = 2
+
+
+                            elif LA43 == 59:
+                                LA43_27 = self.input.LA(3)
+
+                                if (self.synpred82()) :
+                                    alt43 = 1
+                                elif (self.synpred83()) :
+                                    alt43 = 2
+
+
+                            elif LA43 == 60:
+                                LA43_28 = self.input.LA(3)
+
+                                if (self.synpred82()) :
+                                    alt43 = 1
+                                elif (self.synpred83()) :
+                                    alt43 = 2
+
+
+                            elif LA43 == IDENTIFIER:
+                                LA43_29 = self.input.LA(3)
+
+                                if (self.synpred82()) :
+                                    alt43 = 1
+                                elif (self.synpred83()) :
+                                    alt43 = 2
+
+
+                            elif LA43 == 61:
+                                LA43_30 = self.input.LA(3)
+
+                                if (self.synpred82()) :
+                                    alt43 = 1
+                                elif (self.synpred83()) :
+                                    alt43 = 2
+
+
+
+                        elif LA43 == 63:
+                            alt43 = 2
+
+                        if alt43 == 1:
+                            # C.g:277:28: declarator
+                            self.following.append(self.FOLLOW_declarator_in_parameter_declaration982)
+                            self.declarator()
+                            self.following.pop()
+                            if self.failed:
+                                return
+
+
+                        elif alt43 == 2:
+                            # C.g:277:39: abstract_declarator
+                            self.following.append(self.FOLLOW_abstract_declarator_in_parameter_declaration984)
+                            self.abstract_declarator()
+                            self.following.pop()
+                            if self.failed:
+                                return
+
+
+                        else:
+                            break #loop43
+
+
+                    # C.g:277:61: ( 'OPTIONAL' )?
+                    alt44 = 2
+                    LA44_0 = self.input.LA(1)
+
+                    if (LA44_0 == 53) :
+                        alt44 = 1
+                    if alt44 == 1:
+                        # C.g:277:62: 'OPTIONAL'
+                        self.match(self.input, 53, self.FOLLOW_53_in_parameter_declaration989)
+                        if self.failed:
+                            return
+
+
+
+
+
+                elif alt46 == 2:
+                    # C.g:279:4: ( pointer )* IDENTIFIER
+                    # C.g:279:4: ( pointer )*
+                    while True: #loop45
+                        alt45 = 2
+                        LA45_0 = self.input.LA(1)
+
+                        if (LA45_0 == 65) :
+                            alt45 = 1
+
+
+                        if alt45 == 1:
+                            # C.g:0:0: pointer
+                            self.following.append(self.FOLLOW_pointer_in_parameter_declaration998)
+                            self.pointer()
+                            self.following.pop()
+                            if self.failed:
+                                return
+
+
+                        else:
+                            break #loop45
+
+
+                    self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_parameter_declaration1001)
+                    if self.failed:
+                        return
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 28, parameter_declaration_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end parameter_declaration
+
+
+    # $ANTLR start identifier_list
+    # C.g:282:1: identifier_list : IDENTIFIER ( ',' IDENTIFIER )* ;
+    def identifier_list(self, ):
+
+        identifier_list_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 29):
+                    return
+
+                # C.g:283:2: ( IDENTIFIER ( ',' IDENTIFIER )* )
+                # C.g:283:4: IDENTIFIER ( ',' IDENTIFIER )*
+                self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list1012)
+                if self.failed:
+                    return
+                # C.g:284:2: ( ',' IDENTIFIER )*
+                while True: #loop47
+                    alt47 = 2
+                    LA47_0 = self.input.LA(1)
+
+                    if (LA47_0 == 27) :
+                        alt47 = 1
+
+
+                    if alt47 == 1:
+                        # C.g:284:3: ',' IDENTIFIER
+                        self.match(self.input, 27, self.FOLLOW_27_in_identifier_list1016)
+                        if self.failed:
+                            return
+                        self.match(self.input, IDENTIFIER, self.FOLLOW_IDENTIFIER_in_identifier_list1018)
+                        if self.failed:
+                            return
+
+
+                    else:
+                        break #loop47
+
+
+
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 29, identifier_list_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end identifier_list
+
+
+    # $ANTLR start type_name
+    # C.g:287:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );
+    def type_name(self, ):
+
+        type_name_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 30):
+                    return
+
+                # C.g:288:2: ( specifier_qualifier_list ( abstract_declarator )? | type_id )
+                alt49 = 2
+                LA49_0 = self.input.LA(1)
+
+                if ((34 <= LA49_0 <= 42) or (45 <= LA49_0 <= 46) or (48 <= LA49_0 <= 60)) :
+                    alt49 = 1
+                elif (LA49_0 == IDENTIFIER) :
+                    LA49_13 = self.input.LA(2)
+
+                    if (self.synpred89()) :
+                        alt49 = 1
+                    elif (True) :
+                        alt49 = 2
+                    else:
+                        if self.backtracking > 0:
+                            self.failed = True
+                            return
+
+                        nvae = NoViableAltException("287:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 49, 13, self.input)
+
+                        raise nvae
+
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("287:1: type_name : ( specifier_qualifier_list ( abstract_declarator )? | type_id );", 49, 0, self.input)
+
+                    raise nvae
+
+                if alt49 == 1:
+                    # C.g:288:4: specifier_qualifier_list ( abstract_declarator )?
+                    self.following.append(self.FOLLOW_specifier_qualifier_list_in_type_name1031)
+                    self.specifier_qualifier_list()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    # C.g:288:29: ( abstract_declarator )?
+                    alt48 = 2
+                    LA48_0 = self.input.LA(1)
+
+                    if (LA48_0 == 61 or LA48_0 == 63 or LA48_0 == 65) :
+                        alt48 = 1
+                    if alt48 == 1:
+                        # C.g:0:0: abstract_declarator
+                        self.following.append(self.FOLLOW_abstract_declarator_in_type_name1033)
+                        self.abstract_declarator()
+                        self.following.pop()
+                        if self.failed:
+                            return
+
+
+
+
+
+                elif alt49 == 2:
+                    # C.g:289:4: type_id
+                    self.following.append(self.FOLLOW_type_id_in_type_name1039)
+                    self.type_id()
+                    self.following.pop()
+                    if self.failed:
+                        return
+
+
+
+            except RecognitionException, re:
+                self.reportError(re)
+                self.recover(self.input, re)
+        finally:
+            if self.backtracking > 0:
+                self.memoize(self.input, 30, type_name_StartIndex)
+
+            pass
+
+        return
+
+    # $ANTLR end type_name
+
+
+    # $ANTLR start abstract_declarator
+    # C.g:292:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );
+    def abstract_declarator(self, ):
+
+        abstract_declarator_StartIndex = self.input.index()
+        try:
+            try:
+                if self.backtracking > 0 and self.alreadyParsedRule(self.input, 31):
+                    return
+
+                # C.g:293:2: ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator )
+                alt51 = 2
+                LA51_0 = self.input.LA(1)
+
+                if (LA51_0 == 65) :
+                    alt51 = 1
+                elif (LA51_0 == 61 or LA51_0 == 63) :
+                    alt51 = 2
+                else:
+                    if self.backtracking > 0:
+                        self.failed = True
+                        return
+
+                    nvae = NoViableAltException("292:1: abstract_declarator : ( pointer ( direct_abstract_declarator )? | direct_abstract_declarator );", 51, 0, self.input)
+
+                    raise nvae
+
+                if alt51 == 1:
+                    # C.g:293:4: pointer ( direct_abstract_declarator )?
+                    self.following.append(self.FOLLOW_pointer_in_abstract_declarator1050)
+                    self.pointer()
+                    self.following.pop()
+                    if self.failed:
+                        return
+                    # C.g:293:12: ( direct_abstract_declarator )?
+                    alt50 = 2
+                    LA50_0 = self.input.LA(1)
+
+                    if (LA50_0 == 61) :
+                        LA50 = self.input.LA(2)
+                        if LA50 == 62:
+                            LA50_12 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 65:
+                            LA50_13 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 61:
+                            LA50_14 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 63:
+                            LA50_15 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 58:
+                            LA50_16 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 59:
+                            LA50_17 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 60:
+                            LA50_18 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == IDENTIFIER:
+                            LA50_19 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 29 or LA50 == 30 or LA50 == 31 or LA50 == 32 or LA50 == 33:
+                            LA50_20 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 34:
+                            LA50_21 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 35:
+                            LA50_22 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 36:
+                            LA50_23 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 37:
+                            LA50_24 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 38:
+                            LA50_25 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 39:
+                            LA50_26 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 40:
+                            LA50_27 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 41:
+                            LA50_28 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 42:
+                            LA50_29 = self.input.LA(3)
+
+                            if (self.synpred90()) :
+                                alt50 = 1
+                        elif LA50 == 45 or&nbs