BaseTools/Source/Python/Ecc/CLexer.py

   1 # $ANTLR 3.0.1 C.g 2009-02-16 16:02:51
   2
   3 from antlr3 import *
   4 from antlr3.compat import set, frozenset
   5
   6
   7 # for convenience in actions
   8 HIDDEN = BaseRecognizer.HIDDEN
   9
  10 # token types
  11 T29=29
  12 HexDigit=13
  13 T70=70
  14 T74=74
  15 T85=85
  16 T102=102
  17 T114=114
  18 T103=103
  19 STRING_LITERAL=9
  20 T32=32
  21 T81=81
  22 T41=41
  23 FloatTypeSuffix=16
  24 T113=113
  25 T62=62
  26 T109=109
  27 DECIMAL_LITERAL=7
  28 IntegerTypeSuffix=14
  29 T68=68
  30 T73=73
  31 T84=84
  32 T33=33
  33 UnicodeVocabulary=21
  34 T78=78
  35 T115=115
  36 WS=19
  37 LINE_COMMAND=24
  38 T42=42
  39 T96=96
  40 T71=71
  41 LINE_COMMENT=23
  42 T72=72
  43 T94=94
  44 FLOATING_POINT_LITERAL=10
  45 T76=76
  46 UnicodeEscape=18
  47 T75=75
  48 T89=89
  49 T67=67
  50 T31=31
  51 T60=60
  52 T82=82
  53 T100=100
  54 T49=49
  55 IDENTIFIER=4
  56 T30=30
  57 CHARACTER_LITERAL=8
  58 T79=79
  59 T36=36
  60 T58=58
  61 T93=93
  62 T35=35
  63 T107=107
  64 OCTAL_LITERAL=6
  65 T83=83
  66 T61=61
  67 HEX_LITERAL=5
  68 T45=45
  69 T34=34
  70 T101=101
  71 T64=64
  72 T25=25
  73 T91=91
  74 T105=105
  75 T37=37
  76 T86=86
  77 T116=116
  78 EscapeSequence=12
  79 T26=26
  80 T51=51
  81 T111=111
  82 T46=46
  83 T77=77
  84 T38=38
  85 T106=106
  86 T112=112
  87 T69=69
  88 T39=39
  89 T44=44
  90 T55=55
  91 LETTER=11
  92 Exponent=15
  93 T95=95
  94 T50=50
  95 T110=110
  96 T108=108
  97 BS=20
  98 T92=92
  99 T43=43
 100 T28=28
 101 T40=40
 102 T66=66
 103 COMMENT=22
 104 T88=88
 105 T63=63
 106 T57=57
 107 T65=65
 108 T98=98
 109 T56=56
 110 T87=87
 111 T80=80
 112 T59=59
 113 T97=97
 114 T48=48
 115 T54=54
 116 EOF=-1
 117 T104=104
 118 T47=47
 119 Tokens=117
 120 T53=53
 121 OctalEscape=17
 122 T99=99
 123 T27=27
 124 T52=52
 125 T90=90
 126
 127 class CLexer(Lexer):
 128
 129     grammarFileName = "C.g"
 130
 131     def __init__(self, input=None):
 132         Lexer.__init__(self, input)
 133         self.dfa25 = self.DFA25(
 134             self, 25,
 135             eot = self.DFA25_eot,
 136             eof = self.DFA25_eof,
 137             min = self.DFA25_min,
 138             max = self.DFA25_max,
 139             accept = self.DFA25_accept,
 140             special = self.DFA25_special,
 141             transition = self.DFA25_transition
 142             )
 143         self.dfa35 = self.DFA35(
 144             self, 35,
 145             eot = self.DFA35_eot,
 146             eof = self.DFA35_eof,
 147             min = self.DFA35_min,
 148             max = self.DFA35_max,
 149             accept = self.DFA35_accept,
 150             special = self.DFA35_special,
 151             transition = self.DFA35_transition
 152             )
 153
 154
 155
 156
 157
 158
 159     # $ANTLR start T25
 160     def mT25(self, ):
 161
 162         try:
 163             self.type = T25
 164
 165             # C.g:7:5: ( ';' )
 166             # C.g:7:7: ';'
 167             self.match(u';')
 168
 169
 170
 171
 172
 173         finally:
 174
 175             pass
 176
 177     # $ANTLR end T25
 178
 179
 180
 181     # $ANTLR start T26
 182     def mT26(self, ):
 183
 184         try:
 185             self.type = T26
 186
 187             # C.g:8:5: ( 'typedef' )
 188             # C.g:8:7: 'typedef'
 189             self.match("typedef")
 190
 191
 192
 193
 194
 195
 196         finally:
 197
 198             pass
 199
 200     # $ANTLR end T26
 201
 202
 203
 204     # $ANTLR start T27
 205     def mT27(self, ):
 206
 207         try:
 208             self.type = T27
 209
 210             # C.g:9:5: ( ',' )
 211             # C.g:9:7: ','
 212             self.match(u',')
 213
 214
 215
 216
 217
 218         finally:
 219
 220             pass
 221
 222     # $ANTLR end T27
 223
 224
 225
 226     # $ANTLR start T28
 227     def mT28(self, ):
 228
 229         try:
 230             self.type = T28
 231
 232             # C.g:10:5: ( '=' )
 233             # C.g:10:7: '='
 234             self.match(u'=')
 235
 236
 237
 238
 239
 240         finally:
 241
 242             pass
 243
 244     # $ANTLR end T28
 245
 246
 247
 248     # $ANTLR start T29
 249     def mT29(self, ):
 250
 251         try:
 252             self.type = T29
 253
 254             # C.g:11:5: ( 'extern' )
 255             # C.g:11:7: 'extern'
 256             self.match("extern")
 257
 258
 259
 260
 261
 262
 263         finally:
 264
 265             pass
 266
 267     # $ANTLR end T29
 268
 269
 270
 271     # $ANTLR start T30
 272     def mT30(self, ):
 273
 274         try:
 275             self.type = T30
 276
 277             # C.g:12:5: ( 'static' )
 278             # C.g:12:7: 'static'
 279             self.match("static")
 280
 281
 282
 283
 284
 285
 286         finally:
 287
 288             pass
 289
 290     # $ANTLR end T30
 291
 292
 293
 294     # $ANTLR start T31
 295     def mT31(self, ):
 296
 297         try:
 298             self.type = T31
 299
 300             # C.g:13:5: ( 'auto' )
 301             # C.g:13:7: 'auto'
 302             self.match("auto")
 303
 304
 305
 306
 307
 308
 309         finally:
 310
 311             pass
 312
 313     # $ANTLR end T31
 314
 315
 316
 317     # $ANTLR start T32
 318     def mT32(self, ):
 319
 320         try:
 321             self.type = T32
 322
 323             # C.g:14:5: ( 'register' )
 324             # C.g:14:7: 'register'
 325             self.match("register")
 326
 327
 328
 329
 330
 331
 332         finally:
 333
 334             pass
 335
 336     # $ANTLR end T32
 337
 338
 339
 340     # $ANTLR start T33
 341     def mT33(self, ):
 342
 343         try:
 344             self.type = T33
 345
 346             # C.g:15:5: ( 'STATIC' )
 347             # C.g:15:7: 'STATIC'
 348             self.match("STATIC")
 349
 350
 351
 352
 353
 354
 355         finally:
 356
 357             pass
 358
 359     # $ANTLR end T33
 360
 361
 362
 363     # $ANTLR start T34
 364     def mT34(self, ):
 365
 366         try:
 367             self.type = T34
 368
 369             # C.g:16:5: ( 'void' )
 370             # C.g:16:7: 'void'
 371             self.match("void")
 372
 373
 374
 375
 376
 377
 378         finally:
 379
 380             pass
 381
 382     # $ANTLR end T34
 383
 384
 385
 386     # $ANTLR start T35
 387     def mT35(self, ):
 388
 389         try:
 390             self.type = T35
 391
 392             # C.g:17:5: ( 'char' )
 393             # C.g:17:7: 'char'
 394             self.match("char")
 395
 396
 397
 398
 399
 400
 401         finally:
 402
 403             pass
 404
 405     # $ANTLR end T35
 406
 407
 408
 409     # $ANTLR start T36
 410     def mT36(self, ):
 411
 412         try:
 413             self.type = T36
 414
 415             # C.g:18:5: ( 'short' )
 416             # C.g:18:7: 'short'
 417             self.match("short")
 418
 419
 420
 421
 422
 423
 424         finally:
 425
 426             pass
 427
 428     # $ANTLR end T36
 429
 430
 431
 432     # $ANTLR start T37
 433     def mT37(self, ):
 434
 435         try:
 436             self.type = T37
 437
 438             # C.g:19:5: ( 'int' )
 439             # C.g:19:7: 'int'
 440             self.match("int")
 441
 442
 443
 444
 445
 446
 447         finally:
 448
 449             pass
 450
 451     # $ANTLR end T37
 452
 453
 454
 455     # $ANTLR start T38
 456     def mT38(self, ):
 457
 458         try:
 459             self.type = T38
 460
 461             # C.g:20:5: ( 'long' )
 462             # C.g:20:7: 'long'
 463             self.match("long")
 464
 465
 466
 467
 468
 469
 470         finally:
 471
 472             pass
 473
 474     # $ANTLR end T38
 475
 476
 477
 478     # $ANTLR start T39
 479     def mT39(self, ):
 480
 481         try:
 482             self.type = T39
 483
 484             # C.g:21:5: ( 'float' )
 485             # C.g:21:7: 'float'
 486             self.match("float")
 487
 488
 489
 490
 491
 492
 493         finally:
 494
 495             pass
 496
 497     # $ANTLR end T39
 498
 499
 500
 501     # $ANTLR start T40
 502     def mT40(self, ):
 503
 504         try:
 505             self.type = T40
 506
 507             # C.g:22:5: ( 'double' )
 508             # C.g:22:7: 'double'
 509             self.match("double")
 510
 511
 512
 513
 514
 515
 516         finally:
 517
 518             pass
 519
 520     # $ANTLR end T40
 521
 522
 523
 524     # $ANTLR start T41
 525     def mT41(self, ):
 526
 527         try:
 528             self.type = T41
 529
 530             # C.g:23:5: ( 'signed' )
 531             # C.g:23:7: 'signed'
 532             self.match("signed")
 533
 534
 535
 536
 537
 538
 539         finally:
 540
 541             pass
 542
 543     # $ANTLR end T41
 544
 545
 546
 547     # $ANTLR start T42
 548     def mT42(self, ):
 549
 550         try:
 551             self.type = T42
 552
 553             # C.g:24:5: ( 'unsigned' )
 554             # C.g:24:7: 'unsigned'
 555             self.match("unsigned")
 556
 557
 558
 559
 560
 561
 562         finally:
 563
 564             pass
 565
 566     # $ANTLR end T42
 567
 568
 569
 570     # $ANTLR start T43
 571     def mT43(self, ):
 572
 573         try:
 574             self.type = T43
 575
 576             # C.g:25:5: ( '{' )
 577             # C.g:25:7: '{'
 578             self.match(u'{')
 579
 580
 581
 582
 583
 584         finally:
 585
 586             pass
 587
 588     # $ANTLR end T43
 589
 590
 591
 592     # $ANTLR start T44
 593     def mT44(self, ):
 594
 595         try:
 596             self.type = T44
 597
 598             # C.g:26:5: ( '}' )
 599             # C.g:26:7: '}'
 600             self.match(u'}')
 601
 602
 603
 604
 605
 606         finally:
 607
 608             pass
 609
 610     # $ANTLR end T44
 611
 612
 613
 614     # $ANTLR start T45
 615     def mT45(self, ):
 616
 617         try:
 618             self.type = T45
 619
 620             # C.g:27:5: ( 'struct' )
 621             # C.g:27:7: 'struct'
 622             self.match("struct")
 623
 624
 625
 626
 627
 628
 629         finally:
 630
 631             pass
 632
 633     # $ANTLR end T45
 634
 635
 636
 637     # $ANTLR start T46
 638     def mT46(self, ):
 639
 640         try:
 641             self.type = T46
 642
 643             # C.g:28:5: ( 'union' )
 644             # C.g:28:7: 'union'
 645             self.match("union")
 646
 647
 648
 649
 650
 651
 652         finally:
 653
 654             pass
 655
 656     # $ANTLR end T46
 657
 658
 659
 660     # $ANTLR start T47
 661     def mT47(self, ):
 662
 663         try:
 664             self.type = T47
 665
 666             # C.g:29:5: ( ':' )
 667             # C.g:29:7: ':'
 668             self.match(u':')
 669
 670
 671
 672
 673
 674         finally:
 675
 676             pass
 677
 678     # $ANTLR end T47
 679
 680
 681
 682     # $ANTLR start T48
 683     def mT48(self, ):
 684
 685         try:
 686             self.type = T48
 687
 688             # C.g:30:5: ( 'enum' )
 689             # C.g:30:7: 'enum'
 690             self.match("enum")
 691
 692
 693
 694
 695
 696
 697         finally:
 698
 699             pass
 700
 701     # $ANTLR end T48
 702
 703
 704
 705     # $ANTLR start T49
 706     def mT49(self, ):
 707
 708         try:
 709             self.type = T49
 710
 711             # C.g:31:5: ( 'const' )
 712             # C.g:31:7: 'const'
 713             self.match("const")
 714
 715
 716
 717
 718
 719
 720         finally:
 721
 722             pass
 723
 724     # $ANTLR end T49
 725
 726
 727
 728     # $ANTLR start T50
 729     def mT50(self, ):
 730
 731         try:
 732             self.type = T50
 733
 734             # C.g:32:5: ( 'volatile' )
 735             # C.g:32:7: 'volatile'
 736             self.match("volatile")
 737
 738
 739
 740
 741
 742
 743         finally:
 744
 745             pass
 746
 747     # $ANTLR end T50
 748
 749
 750
 751     # $ANTLR start T51
 752     def mT51(self, ):
 753
 754         try:
 755             self.type = T51
 756
 757             # C.g:33:5: ( 'IN' )
 758             # C.g:33:7: 'IN'
 759             self.match("IN")
 760
 761
 762
 763
 764
 765
 766         finally:
 767
 768             pass
 769
 770     # $ANTLR end T51
 771
 772
 773
 774     # $ANTLR start T52
 775     def mT52(self, ):
 776
 777         try:
 778             self.type = T52
 779
 780             # C.g:34:5: ( 'OUT' )
 781             # C.g:34:7: 'OUT'
 782             self.match("OUT")
 783
 784
 785
 786
 787
 788
 789         finally:
 790
 791             pass
 792
 793     # $ANTLR end T52
 794
 795
 796
 797     # $ANTLR start T53
 798     def mT53(self, ):
 799
 800         try:
 801             self.type = T53
 802
 803             # C.g:35:5: ( 'OPTIONAL' )
 804             # C.g:35:7: 'OPTIONAL'
 805             self.match("OPTIONAL")
 806
 807
 808
 809
 810
 811
 812         finally:
 813
 814             pass
 815
 816     # $ANTLR end T53
 817
 818
 819
 820     # $ANTLR start T54
 821     def mT54(self, ):
 822
 823         try:
 824             self.type = T54
 825
 826             # C.g:36:5: ( 'CONST' )
 827             # C.g:36:7: 'CONST'
 828             self.match("CONST")
 829
 830
 831
 832
 833
 834
 835         finally:
 836
 837             pass
 838
 839     # $ANTLR end T54
 840
 841
 842
 843     # $ANTLR start T55
 844     def mT55(self, ):
 845
 846         try:
 847             self.type = T55
 848
 849             # C.g:37:5: ( 'UNALIGNED' )
 850             # C.g:37:7: 'UNALIGNED'
 851             self.match("UNALIGNED")
 852
 853
 854
 855
 856
 857
 858         finally:
 859
 860             pass
 861
 862     # $ANTLR end T55
 863
 864
 865
 866     # $ANTLR start T56
 867     def mT56(self, ):
 868
 869         try:
 870             self.type = T56
 871
 872             # C.g:38:5: ( 'VOLATILE' )
 873             # C.g:38:7: 'VOLATILE'
 874             self.match("VOLATILE")
 875
 876
 877
 878
 879
 880
 881         finally:
 882
 883             pass
 884
 885     # $ANTLR end T56
 886
 887
 888
 889     # $ANTLR start T57
 890     def mT57(self, ):
 891
 892         try:
 893             self.type = T57
 894
 895             # C.g:39:5: ( 'GLOBAL_REMOVE_IF_UNREFERENCED' )
 896             # C.g:39:7: 'GLOBAL_REMOVE_IF_UNREFERENCED'
 897             self.match("GLOBAL_REMOVE_IF_UNREFERENCED")
 898
 899
 900
 901
 902
 903
 904         finally:
 905
 906             pass
 907
 908     # $ANTLR end T57
 909
 910
 911
 912     # $ANTLR start T58
 913     def mT58(self, ):
 914
 915         try:
 916             self.type = T58
 917
 918             # C.g:40:5: ( 'EFIAPI' )
 919             # C.g:40:7: 'EFIAPI'
 920             self.match("EFIAPI")
 921
 922
 923
 924
 925
 926
 927         finally:
 928
 929             pass
 930
 931     # $ANTLR end T58
 932
 933
 934
 935     # $ANTLR start T59
 936     def mT59(self, ):
 937
 938         try:
 939             self.type = T59
 940
 941             # C.g:41:5: ( 'EFI_BOOTSERVICE' )
 942             # C.g:41:7: 'EFI_BOOTSERVICE'
 943             self.match("EFI_BOOTSERVICE")
 944
 945
 946
 947
 948
 949
 950         finally:
 951
 952             pass
 953
 954     # $ANTLR end T59
 955
 956
 957
 958     # $ANTLR start T60
 959     def mT60(self, ):
 960
 961         try:
 962             self.type = T60
 963
 964             # C.g:42:5: ( 'EFI_RUNTIMESERVICE' )
 965             # C.g:42:7: 'EFI_RUNTIMESERVICE'
 966             self.match("EFI_RUNTIMESERVICE")
 967
 968
 969
 970
 971
 972
 973         finally:
 974
 975             pass
 976
 977     # $ANTLR end T60
 978
 979
 980
 981     # $ANTLR start T61
 982     def mT61(self, ):
 983
 984         try:
 985             self.type = T61
 986
 987             # C.g:43:5: ( '(' )
 988             # C.g:43:7: '('
 989             self.match(u'(')
 990
 991
 992
 993
 994
 995         finally:
 996
 997             pass
 998
 999     # $ANTLR end T61
1000
1001
1002
1003     # $ANTLR start T62
1004     def mT62(self, ):
1005
1006         try:
1007             self.type = T62
1008
1009             # C.g:44:5: ( ')' )
1010             # C.g:44:7: ')'
1011             self.match(u')')
1012
1013
1014
1015
1016
1017         finally:
1018
1019             pass
1020
1021     # $ANTLR end T62
1022
1023
1024
1025     # $ANTLR start T63
1026     def mT63(self, ):
1027
1028         try:
1029             self.type = T63
1030
1031             # C.g:45:5: ( '[' )
1032             # C.g:45:7: '['
1033             self.match(u'[')
1034
1035
1036
1037
1038
1039         finally:
1040
1041             pass
1042
1043     # $ANTLR end T63
1044
1045
1046
1047     # $ANTLR start T64
1048     def mT64(self, ):
1049
1050         try:
1051             self.type = T64
1052
1053             # C.g:46:5: ( ']' )
1054             # C.g:46:7: ']'
1055             self.match(u']')
1056
1057
1058
1059
1060
1061         finally:
1062
1063             pass
1064
1065     # $ANTLR end T64
1066
1067
1068
1069     # $ANTLR start T65
1070     def mT65(self, ):
1071
1072         try:
1073             self.type = T65
1074
1075             # C.g:47:5: ( '*' )
1076             # C.g:47:7: '*'
1077             self.match(u'*')
1078
1079
1080
1081
1082
1083         finally:
1084
1085             pass
1086
1087     # $ANTLR end T65
1088
1089
1090
1091     # $ANTLR start T66
1092     def mT66(self, ):
1093
1094         try:
1095             self.type = T66
1096
1097             # C.g:48:5: ( '...' )
1098             # C.g:48:7: '...'
1099             self.match("...")
1100
1101
1102
1103
1104
1105
1106         finally:
1107
1108             pass
1109
1110     # $ANTLR end T66
1111
1112
1113
1114     # $ANTLR start T67
1115     def mT67(self, ):
1116
1117         try:
1118             self.type = T67
1119
1120             # C.g:49:5: ( '+' )
1121             # C.g:49:7: '+'
1122             self.match(u'+')
1123
1124
1125
1126
1127
1128         finally:
1129
1130             pass
1131
1132     # $ANTLR end T67
1133
1134
1135
1136     # $ANTLR start T68
1137     def mT68(self, ):
1138
1139         try:
1140             self.type = T68
1141
1142             # C.g:50:5: ( '-' )
1143             # C.g:50:7: '-'
1144             self.match(u'-')
1145
1146
1147
1148
1149
1150         finally:
1151
1152             pass
1153
1154     # $ANTLR end T68
1155
1156
1157
1158     # $ANTLR start T69
1159     def mT69(self, ):
1160
1161         try:
1162             self.type = T69
1163
1164             # C.g:51:5: ( '/' )
1165             # C.g:51:7: '/'
1166             self.match(u'/')
1167
1168
1169
1170
1171
1172         finally:
1173
1174             pass
1175
1176     # $ANTLR end T69
1177
1178
1179
1180     # $ANTLR start T70
1181     def mT70(self, ):
1182
1183         try:
1184             self.type = T70
1185
1186             # C.g:52:5: ( '%' )
1187             # C.g:52:7: '%'
1188             self.match(u'%')
1189
1190
1191
1192
1193
1194         finally:
1195
1196             pass
1197
1198     # $ANTLR end T70
1199
1200
1201
1202     # $ANTLR start T71
1203     def mT71(self, ):
1204
1205         try:
1206             self.type = T71
1207
1208             # C.g:53:5: ( '++' )
1209             # C.g:53:7: '++'
1210             self.match("++")
1211
1212
1213
1214
1215
1216
1217         finally:
1218
1219             pass
1220
1221     # $ANTLR end T71
1222
1223
1224
1225     # $ANTLR start T72
1226     def mT72(self, ):
1227
1228         try:
1229             self.type = T72
1230
1231             # C.g:54:5: ( '--' )
1232             # C.g:54:7: '--'
1233             self.match("--")
1234
1235
1236
1237
1238
1239
1240         finally:
1241
1242             pass
1243
1244     # $ANTLR end T72
1245
1246
1247
1248     # $ANTLR start T73
1249     def mT73(self, ):
1250
1251         try:
1252             self.type = T73
1253
1254             # C.g:55:5: ( 'sizeof' )
1255             # C.g:55:7: 'sizeof'
1256             self.match("sizeof")
1257
1258
1259
1260
1261
1262
1263         finally:
1264
1265             pass
1266
1267     # $ANTLR end T73
1268
1269
1270
1271     # $ANTLR start T74
1272     def mT74(self, ):
1273
1274         try:
1275             self.type = T74
1276
1277             # C.g:56:5: ( '.' )
1278             # C.g:56:7: '.'
1279             self.match(u'.')
1280
1281
1282
1283
1284
1285         finally:
1286
1287             pass
1288
1289     # $ANTLR end T74
1290
1291
1292
1293     # $ANTLR start T75
1294     def mT75(self, ):
1295
1296         try:
1297             self.type = T75
1298
1299             # C.g:57:5: ( '->' )
1300             # C.g:57:7: '->'
1301             self.match("->")
1302
1303
1304
1305
1306
1307
1308         finally:
1309
1310             pass
1311
1312     # $ANTLR end T75
1313
1314
1315
1316     # $ANTLR start T76
1317     def mT76(self, ):
1318
1319         try:
1320             self.type = T76
1321
1322             # C.g:58:5: ( '&' )
1323             # C.g:58:7: '&'
1324             self.match(u'&')
1325
1326
1327
1328
1329
1330         finally:
1331
1332             pass
1333
1334     # $ANTLR end T76
1335
1336
1337
1338     # $ANTLR start T77
1339     def mT77(self, ):
1340
1341         try:
1342             self.type = T77
1343
1344             # C.g:59:5: ( '~' )
1345             # C.g:59:7: '~'
1346             self.match(u'~')
1347
1348
1349
1350
1351
1352         finally:
1353
1354             pass
1355
1356     # $ANTLR end T77
1357
1358
1359
1360     # $ANTLR start T78
1361     def mT78(self, ):
1362
1363         try:
1364             self.type = T78
1365
1366             # C.g:60:5: ( '!' )
1367             # C.g:60:7: '!'
1368             self.match(u'!')
1369
1370
1371
1372
1373
1374         finally:
1375
1376             pass
1377
1378     # $ANTLR end T78
1379
1380
1381
1382     # $ANTLR start T79
1383     def mT79(self, ):
1384
1385         try:
1386             self.type = T79
1387
1388             # C.g:61:5: ( '*=' )
1389             # C.g:61:7: '*='
1390             self.match("*=")
1391
1392
1393
1394
1395
1396
1397         finally:
1398
1399             pass
1400
1401     # $ANTLR end T79
1402
1403
1404
1405     # $ANTLR start T80
1406     def mT80(self, ):
1407
1408         try:
1409             self.type = T80
1410
1411             # C.g:62:5: ( '/=' )
1412             # C.g:62:7: '/='
1413             self.match("/=")
1414
1415
1416
1417
1418
1419
1420         finally:
1421
1422             pass
1423
1424     # $ANTLR end T80
1425
1426
1427
1428     # $ANTLR start T81
1429     def mT81(self, ):
1430
1431         try:
1432             self.type = T81
1433
1434             # C.g:63:5: ( '%=' )
1435             # C.g:63:7: '%='
1436             self.match("%=")
1437
1438
1439
1440
1441
1442
1443         finally:
1444
1445             pass
1446
1447     # $ANTLR end T81
1448
1449
1450
1451     # $ANTLR start T82
1452     def mT82(self, ):
1453
1454         try:
1455             self.type = T82
1456
1457             # C.g:64:5: ( '+=' )
1458             # C.g:64:7: '+='
1459             self.match("+=")
1460
1461
1462
1463
1464
1465
1466         finally:
1467
1468             pass
1469
1470     # $ANTLR end T82
1471
1472
1473
1474     # $ANTLR start T83
1475     def mT83(self, ):
1476
1477         try:
1478             self.type = T83
1479
1480             # C.g:65:5: ( '-=' )
1481             # C.g:65:7: '-='
1482             self.match("-=")
1483
1484
1485
1486
1487
1488
1489         finally:
1490
1491             pass
1492
1493     # $ANTLR end T83
1494
1495
1496
1497     # $ANTLR start T84
1498     def mT84(self, ):
1499
1500         try:
1501             self.type = T84
1502
1503             # C.g:66:5: ( '<<=' )
1504             # C.g:66:7: '<<='
1505             self.match("<<=")
1506
1507
1508
1509
1510
1511
1512         finally:
1513
1514             pass
1515
1516     # $ANTLR end T84
1517
1518
1519
1520     # $ANTLR start T85
1521     def mT85(self, ):
1522
1523         try:
1524             self.type = T85
1525
1526             # C.g:67:5: ( '>>=' )
1527             # C.g:67:7: '>>='
1528             self.match(">>=")
1529
1530
1531
1532
1533
1534
1535         finally:
1536
1537             pass
1538
1539     # $ANTLR end T85
1540
1541
1542
1543     # $ANTLR start T86
1544     def mT86(self, ):
1545
1546         try:
1547             self.type = T86
1548
1549             # C.g:68:5: ( '&=' )
1550             # C.g:68:7: '&='
1551             self.match("&=")
1552
1553
1554
1555
1556
1557
1558         finally:
1559
1560             pass
1561
1562     # $ANTLR end T86
1563
1564
1565
1566     # $ANTLR start T87
1567     def mT87(self, ):
1568
1569         try:
1570             self.type = T87
1571
1572             # C.g:69:5: ( '^=' )
1573             # C.g:69:7: '^='
1574             self.match("^=")
1575
1576
1577
1578
1579
1580
1581         finally:
1582
1583             pass
1584
1585     # $ANTLR end T87
1586
1587
1588
1589     # $ANTLR start T88
1590     def mT88(self, ):
1591
1592         try:
1593             self.type = T88
1594
1595             # C.g:70:5: ( '|=' )
1596             # C.g:70:7: '|='
1597             self.match("|=")
1598
1599
1600
1601
1602
1603
1604         finally:
1605
1606             pass
1607
1608     # $ANTLR end T88
1609
1610
1611
1612     # $ANTLR start T89
1613     def mT89(self, ):
1614
1615         try:
1616             self.type = T89
1617
1618             # C.g:71:5: ( '?' )
1619             # C.g:71:7: '?'
1620             self.match(u'?')
1621
1622
1623
1624
1625
1626         finally:
1627
1628             pass
1629
1630     # $ANTLR end T89
1631
1632
1633
1634     # $ANTLR start T90
1635     def mT90(self, ):
1636
1637         try:
1638             self.type = T90
1639
1640             # C.g:72:5: ( '||' )
1641             # C.g:72:7: '||'
1642             self.match("||")
1643
1644
1645
1646
1647
1648
1649         finally:
1650
1651             pass
1652
1653     # $ANTLR end T90
1654
1655
1656
1657     # $ANTLR start T91
1658     def mT91(self, ):
1659
1660         try:
1661             self.type = T91
1662
1663             # C.g:73:5: ( '&&' )
1664             # C.g:73:7: '&&'
1665             self.match("&&")
1666
1667
1668
1669
1670
1671
1672         finally:
1673
1674             pass
1675
1676     # $ANTLR end T91
1677
1678
1679
1680     # $ANTLR start T92
1681     def mT92(self, ):
1682
1683         try:
1684             self.type = T92
1685
1686             # C.g:74:5: ( '|' )
1687             # C.g:74:7: '|'
1688             self.match(u'|')
1689
1690
1691
1692
1693
1694         finally:
1695
1696             pass
1697
1698     # $ANTLR end T92
1699
1700
1701
1702     # $ANTLR start T93
1703     def mT93(self, ):
1704
1705         try:
1706             self.type = T93
1707
1708             # C.g:75:5: ( '^' )
1709             # C.g:75:7: '^'
1710             self.match(u'^')
1711
1712
1713
1714
1715
1716         finally:
1717
1718             pass
1719
1720     # $ANTLR end T93
1721
1722
1723
1724     # $ANTLR start T94
1725     def mT94(self, ):
1726
1727         try:
1728             self.type = T94
1729
1730             # C.g:76:5: ( '==' )
1731             # C.g:76:7: '=='
1732             self.match("==")
1733
1734
1735
1736
1737
1738
1739         finally:
1740
1741             pass
1742
1743     # $ANTLR end T94
1744
1745
1746
1747     # $ANTLR start T95
1748     def mT95(self, ):
1749
1750         try:
1751             self.type = T95
1752
1753             # C.g:77:5: ( '!=' )
1754             # C.g:77:7: '!='
1755             self.match("!=")
1756
1757
1758
1759
1760
1761
1762         finally:
1763
1764             pass
1765
1766     # $ANTLR end T95
1767
1768
1769
1770     # $ANTLR start T96
1771     def mT96(self, ):
1772
1773         try:
1774             self.type = T96
1775
1776             # C.g:78:5: ( '<' )
1777             # C.g:78:7: '<'
1778             self.match(u'<')
1779
1780
1781
1782
1783
1784         finally:
1785
1786             pass
1787
1788     # $ANTLR end T96
1789
1790
1791
1792     # $ANTLR start T97
1793     def mT97(self, ):
1794
1795         try:
1796             self.type = T97
1797
1798             # C.g:79:5: ( '>' )
1799             # C.g:79:7: '>'
1800             self.match(u'>')
1801
1802
1803
1804
1805
1806         finally:
1807
1808             pass
1809
1810     # $ANTLR end T97
1811
1812
1813
1814     # $ANTLR start T98
1815     def mT98(self, ):
1816
1817         try:
1818             self.type = T98
1819
1820             # C.g:80:5: ( '<=' )
1821             # C.g:80:7: '<='
1822             self.match("<=")
1823
1824
1825
1826
1827
1828
1829         finally:
1830
1831             pass
1832
1833     # $ANTLR end T98
1834
1835
1836
1837     # $ANTLR start T99
1838     def mT99(self, ):
1839
1840         try:
1841             self.type = T99
1842
1843             # C.g:81:5: ( '>=' )
1844             # C.g:81:7: '>='
1845             self.match(">=")
1846
1847
1848
1849
1850
1851
1852         finally:
1853
1854             pass
1855
1856     # $ANTLR end T99
1857
1858
1859
1860     # $ANTLR start T100
1861     def mT100(self, ):
1862
1863         try:
1864             self.type = T100
1865
1866             # C.g:82:6: ( '<<' )
1867             # C.g:82:8: '<<'
1868             self.match("<<")
1869
1870
1871
1872
1873
1874
1875         finally:
1876
1877             pass
1878
1879     # $ANTLR end T100
1880
1881
1882
1883     # $ANTLR start T101
1884     def mT101(self, ):
1885
1886         try:
1887             self.type = T101
1888
1889             # C.g:83:6: ( '>>' )
1890             # C.g:83:8: '>>'
1891             self.match(">>")
1892
1893
1894
1895
1896
1897
1898         finally:
1899
1900             pass
1901
1902     # $ANTLR end T101
1903
1904
1905
1906     # $ANTLR start T102
1907     def mT102(self, ):
1908
1909         try:
1910             self.type = T102
1911
1912             # C.g:84:6: ( '__asm__' )
1913             # C.g:84:8: '__asm__'
1914             self.match("__asm__")
1915
1916
1917
1918
1919
1920
1921         finally:
1922
1923             pass
1924
1925     # $ANTLR end T102
1926
1927
1928
1929     # $ANTLR start T103
1930     def mT103(self, ):
1931
1932         try:
1933             self.type = T103
1934
1935             # C.g:85:6: ( '_asm' )
1936             # C.g:85:8: '_asm'
1937             self.match("_asm")
1938
1939
1940
1941
1942
1943
1944         finally:
1945
1946             pass
1947
1948     # $ANTLR end T103
1949
1950
1951
1952     # $ANTLR start T104
1953     def mT104(self, ):
1954
1955         try:
1956             self.type = T104
1957
1958             # C.g:86:6: ( '__asm' )
1959             # C.g:86:8: '__asm'
1960             self.match("__asm")
1961
1962
1963
1964
1965
1966
1967         finally:
1968
1969             pass
1970
1971     # $ANTLR end T104
1972
1973
1974
1975     # $ANTLR start T105
1976     def mT105(self, ):
1977
1978         try:
1979             self.type = T105
1980
1981             # C.g:87:6: ( 'case' )
1982             # C.g:87:8: 'case'
1983             self.match("case")
1984
1985
1986
1987
1988
1989
1990         finally:
1991
1992             pass
1993
1994     # $ANTLR end T105
1995
1996
1997
1998     # $ANTLR start T106
1999     def mT106(self, ):
2000
2001         try:
2002             self.type = T106
2003
2004             # C.g:88:6: ( 'default' )
2005             # C.g:88:8: 'default'
2006             self.match("default")
2007
2008
2009
2010
2011
2012
2013         finally:
2014
2015             pass
2016
2017     # $ANTLR end T106
2018
2019
2020
2021     # $ANTLR start T107
2022     def mT107(self, ):
2023
2024         try:
2025             self.type = T107
2026
2027             # C.g:89:6: ( 'if' )
2028             # C.g:89:8: 'if'
2029             self.match("if")
2030
2031
2032
2033
2034
2035
2036         finally:
2037
2038             pass
2039
2040     # $ANTLR end T107
2041
2042
2043
2044     # $ANTLR start T108
2045     def mT108(self, ):
2046
2047         try:
2048             self.type = T108
2049
2050             # C.g:90:6: ( 'else' )
2051             # C.g:90:8: 'else'
2052             self.match("else")
2053
2054
2055
2056
2057
2058
2059         finally:
2060
2061             pass
2062
2063     # $ANTLR end T108
2064
2065
2066
2067     # $ANTLR start T109
2068     def mT109(self, ):
2069
2070         try:
2071             self.type = T109
2072
2073             # C.g:91:6: ( 'switch' )
2074             # C.g:91:8: 'switch'
2075             self.match("switch")
2076
2077
2078
2079
2080
2081
2082         finally:
2083
2084             pass
2085
2086     # $ANTLR end T109
2087
2088
2089
2090     # $ANTLR start T110
2091     def mT110(self, ):
2092
2093         try:
2094             self.type = T110
2095
2096             # C.g:92:6: ( 'while' )
2097             # C.g:92:8: 'while'
2098             self.match("while")
2099
2100
2101
2102
2103
2104
2105         finally:
2106
2107             pass
2108
2109     # $ANTLR end T110
2110
2111
2112
2113     # $ANTLR start T111
2114     def mT111(self, ):
2115
2116         try:
2117             self.type = T111
2118
2119             # C.g:93:6: ( 'do' )
2120             # C.g:93:8: 'do'
2121             self.match("do")
2122
2123
2124
2125
2126
2127
2128         finally:
2129
2130             pass
2131
2132     # $ANTLR end T111
2133
2134
2135
2136     # $ANTLR start T112
2137     def mT112(self, ):
2138
2139         try:
2140             self.type = T112
2141
2142             # C.g:94:6: ( 'for' )
2143             # C.g:94:8: 'for'
2144             self.match("for")
2145
2146
2147
2148
2149
2150
2151         finally:
2152
2153             pass
2154
2155     # $ANTLR end T112
2156
2157
2158
2159     # $ANTLR start T113
2160     def mT113(self, ):
2161
2162         try:
2163             self.type = T113
2164
2165             # C.g:95:6: ( 'goto' )
2166             # C.g:95:8: 'goto'
2167             self.match("goto")
2168
2169
2170
2171
2172
2173
2174         finally:
2175
2176             pass
2177
2178     # $ANTLR end T113
2179
2180
2181
2182     # $ANTLR start T114
2183     def mT114(self, ):
2184
2185         try:
2186             self.type = T114
2187
2188             # C.g:96:6: ( 'continue' )
2189             # C.g:96:8: 'continue'
2190             self.match("continue")
2191
2192
2193
2194
2195
2196
2197         finally:
2198
2199             pass
2200
2201     # $ANTLR end T114
2202
2203
2204
2205     # $ANTLR start T115
2206     def mT115(self, ):
2207
2208         try:
2209             self.type = T115
2210
2211             # C.g:97:6: ( 'break' )
2212             # C.g:97:8: 'break'
2213             self.match("break")
2214
2215
2216
2217
2218
2219
2220         finally:
2221
2222             pass
2223
2224     # $ANTLR end T115
2225
2226
2227
2228     # $ANTLR start T116
2229     def mT116(self, ):
2230
2231         try:
2232             self.type = T116
2233
2234             # C.g:98:6: ( 'return' )
2235             # C.g:98:8: 'return'
2236             self.match("return")
2237
2238
2239
2240
2241
2242
2243         finally:
2244
2245             pass
2246
2247     # $ANTLR end T116
2248
2249
2250
2251     # $ANTLR start IDENTIFIER
2252     def mIDENTIFIER(self, ):
2253
2254         try:
2255             self.type = IDENTIFIER
2256
2257             # C.g:533:2: ( LETTER ( LETTER | '0' .. '9' )* )
2258             # C.g:533:4: LETTER ( LETTER | '0' .. '9' )*
2259             self.mLETTER()
2260
2261             # C.g:533:11: ( LETTER | '0' .. '9' )*
2262             while True: #loop1
2263                 alt1 = 2
2264                 LA1_0 = self.input.LA(1)
2265
2266                 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')) :
2267                     alt1 = 1
2268
2269
2270                 if alt1 == 1:
2271                     # C.g:
2272                     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'):
2273                         self.input.consume();
2274
2275                     else:
2276                         mse = MismatchedSetException(None, self.input)
2277                         self.recover(mse)
2278                         raise mse
2279
2280
2281
2282
2283                 else:
2284                     break #loop1
2285
2286
2287
2288
2289
2290
2291         finally:
2292
2293             pass
2294
2295     # $ANTLR end IDENTIFIER
2296
2297
2298
2299     # $ANTLR start LETTER
2300     def mLETTER(self, ):
2301
2302         try:
2303             # C.g:538:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' )
2304             # C.g:
2305             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'):
2306                 self.input.consume();
2307
2308             else:
2309                 mse = MismatchedSetException(None, self.input)
2310                 self.recover(mse)
2311                 raise mse
2312
2313
2314
2315
2316
2317
2318         finally:
2319
2320             pass
2321
2322     # $ANTLR end LETTER
2323
2324
2325
2326     # $ANTLR start CHARACTER_LITERAL
2327     def mCHARACTER_LITERAL(self, ):
2328
2329         try:
2330             self.type = CHARACTER_LITERAL
2331
2332             # C.g:545:5: ( ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' )
2333             # C.g:545:9: ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\''
2334             # C.g:545:9: ( 'L' )?
2335             alt2 = 2
2336             LA2_0 = self.input.LA(1)
2337
2338             if (LA2_0 == u'L') :
2339                 alt2 = 1
2340             if alt2 == 1:
2341                 # C.g:545:10: 'L'
2342                 self.match(u'L')
2343
2344
2345
2346
2347             self.match(u'\'')
2348
2349             # C.g:545:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )
2350             alt3 = 2
2351             LA3_0 = self.input.LA(1)
2352
2353             if (LA3_0 == u'\\') :
2354                 alt3 = 1
2355             elif ((u'\u0000' <= LA3_0 <= u'&') or (u'(' <= LA3_0 <= u'[') or (u']' <= LA3_0 <= u'\uFFFE')) :
2356                 alt3 = 2
2357             else:
2358                 nvae = NoViableAltException("545:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )", 3, 0, self.input)
2359
2360                 raise nvae
2361
2362             if alt3 == 1:
2363                 # C.g:545:23: EscapeSequence
2364                 self.mEscapeSequence()
2365
2366
2367
2368             elif alt3 == 2:
2369                 # C.g:545:40: ~ ( '\\'' | '\\\\' )
2370                 if (u'\u0000' <= self.input.LA(1) <= u'&') or (u'(' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):
2371                     self.input.consume();
2372
2373                 else:
2374                     mse = MismatchedSetException(None, self.input)
2375                     self.recover(mse)
2376                     raise mse
2377
2378
2379
2380
2381
2382             self.match(u'\'')
2383
2384
2385
2386
2387
2388         finally:
2389
2390             pass
2391
2392     # $ANTLR end CHARACTER_LITERAL
2393
2394
2395
2396     # $ANTLR start STRING_LITERAL
2397     def mSTRING_LITERAL(self, ):
2398
2399         try:
2400             self.type = STRING_LITERAL
2401
2402             # C.g:549:5: ( ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' )
2403             # C.g:549:8: ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"'
2404             # C.g:549:8: ( 'L' )?
2405             alt4 = 2
2406             LA4_0 = self.input.LA(1)
2407
2408             if (LA4_0 == u'L') :
2409                 alt4 = 1
2410             if alt4 == 1:
2411                 # C.g:549:9: 'L'
2412                 self.match(u'L')
2413
2414
2415
2416
2417             self.match(u'"')
2418
2419             # C.g:549:19: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )*
2420             while True: #loop5
2421                 alt5 = 3
2422                 LA5_0 = self.input.LA(1)
2423
2424                 if (LA5_0 == u'\\') :
2425                     alt5 = 1
2426                 elif ((u'\u0000' <= LA5_0 <= u'!') or (u'#' <= LA5_0 <= u'[') or (u']' <= LA5_0 <= u'\uFFFE')) :
2427                     alt5 = 2
2428
2429
2430                 if alt5 == 1:
2431                     # C.g:549:21: EscapeSequence
2432                     self.mEscapeSequence()
2433
2434
2435
2436                 elif alt5 == 2:
2437                     # C.g:549:38: ~ ( '\\\\' | '\"' )
2438                     if (u'\u0000' <= self.input.LA(1) <= u'!') or (u'#' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):
2439                         self.input.consume();
2440
2441                     else:
2442                         mse = MismatchedSetException(None, self.input)
2443                         self.recover(mse)
2444                         raise mse
2445
2446
2447
2448
2449                 else:
2450                     break #loop5
2451
2452
2453             self.match(u'"')
2454
2455
2456
2457
2458
2459         finally:
2460
2461             pass
2462
2463     # $ANTLR end STRING_LITERAL
2464
2465
2466
2467     # $ANTLR start HEX_LITERAL
2468     def mHEX_LITERAL(self, ):
2469
2470         try:
2471             self.type = HEX_LITERAL
2472
2473             # C.g:552:13: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? )
2474             # C.g:552:15: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )?
2475             self.match(u'0')
2476
2477             if self.input.LA(1) == u'X' or self.input.LA(1) == u'x':
2478                 self.input.consume();
2479
2480             else:
2481                 mse = MismatchedSetException(None, self.input)
2482                 self.recover(mse)
2483                 raise mse
2484
2485
2486             # C.g:552:29: ( HexDigit )+
2487             cnt6 = 0
2488             while True: #loop6
2489                 alt6 = 2
2490                 LA6_0 = self.input.LA(1)
2491
2492                 if ((u'0' <= LA6_0 <= u'9') or (u'A' <= LA6_0 <= u'F') or (u'a' <= LA6_0 <= u'f')) :
2493                     alt6 = 1
2494
2495
2496                 if alt6 == 1:
2497                     # C.g:552:29: HexDigit
2498                     self.mHexDigit()
2499
2500
2501
2502                 else:
2503                     if cnt6 >= 1:
2504                         break #loop6
2505
2506                     eee = EarlyExitException(6, self.input)
2507                     raise eee
2508
2509                 cnt6 += 1
2510
2511
2512             # C.g:552:39: ( IntegerTypeSuffix )?
2513             alt7 = 2
2514             LA7_0 = self.input.LA(1)
2515
2516             if (LA7_0 == u'L' or LA7_0 == u'U' or LA7_0 == u'l' or LA7_0 == u'u') :
2517                 alt7 = 1
2518             if alt7 == 1:
2519                 # C.g:552:39: IntegerTypeSuffix
2520                 self.mIntegerTypeSuffix()
2521
2522
2523
2524
2525
2526
2527
2528
2529         finally:
2530
2531             pass
2532
2533     # $ANTLR end HEX_LITERAL
2534
2535
2536
2537     # $ANTLR start DECIMAL_LITERAL
2538     def mDECIMAL_LITERAL(self, ):
2539
2540         try:
2541             self.type = DECIMAL_LITERAL
2542
2543             # C.g:554:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? )
2544             # C.g:554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )?
2545             # C.g:554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )
2546             alt9 = 2
2547             LA9_0 = self.input.LA(1)
2548
2549             if (LA9_0 == u'0') :
2550                 alt9 = 1
2551             elif ((u'1' <= LA9_0 <= u'9')) :
2552                 alt9 = 2
2553             else:
2554                 nvae = NoViableAltException("554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )", 9, 0, self.input)
2555
2556                 raise nvae
2557
2558             if alt9 == 1:
2559                 # C.g:554:20: '0'
2560                 self.match(u'0')
2561
2562
2563
2564             elif alt9 == 2:
2565                 # C.g:554:26: '1' .. '9' ( '0' .. '9' )*
2566                 self.matchRange(u'1', u'9')
2567
2568                 # C.g:554:35: ( '0' .. '9' )*
2569                 while True: #loop8
2570                     alt8 = 2
2571                     LA8_0 = self.input.LA(1)
2572
2573                     if ((u'0' <= LA8_0 <= u'9')) :
2574                         alt8 = 1
2575
2576
2577                     if alt8 == 1:
2578                         # C.g:554:35: '0' .. '9'
2579                         self.matchRange(u'0', u'9')
2580
2581
2582
2583                     else:
2584                         break #loop8
2585
2586
2587
2588
2589
2590             # C.g:554:46: ( IntegerTypeSuffix )?
2591             alt10 = 2
2592             LA10_0 = self.input.LA(1)
2593
2594             if (LA10_0 == u'L' or LA10_0 == u'U' or LA10_0 == u'l' or LA10_0 == u'u') :
2595                 alt10 = 1
2596             if alt10 == 1:
2597                 # C.g:554:46: IntegerTypeSuffix
2598                 self.mIntegerTypeSuffix()
2599
2600
2601
2602
2603
2604
2605
2606
2607         finally:
2608
2609             pass
2610
2611     # $ANTLR end DECIMAL_LITERAL
2612
2613
2614
2615     # $ANTLR start OCTAL_LITERAL
2616     def mOCTAL_LITERAL(self, ):
2617
2618         try:
2619             self.type = OCTAL_LITERAL
2620
2621             # C.g:556:15: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? )
2622             # C.g:556:17: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )?
2623             self.match(u'0')
2624
2625             # C.g:556:21: ( '0' .. '7' )+
2626             cnt11 = 0
2627             while True: #loop11
2628                 alt11 = 2
2629                 LA11_0 = self.input.LA(1)
2630
2631                 if ((u'0' <= LA11_0 <= u'7')) :
2632                     alt11 = 1
2633
2634
2635                 if alt11 == 1:
2636                     # C.g:556:22: '0' .. '7'
2637                     self.matchRange(u'0', u'7')
2638
2639
2640
2641                 else:
2642                     if cnt11 >= 1:
2643                         break #loop11
2644
2645                     eee = EarlyExitException(11, self.input)
2646                     raise eee
2647
2648                 cnt11 += 1
2649
2650
2651             # C.g:556:33: ( IntegerTypeSuffix )?
2652             alt12 = 2
2653             LA12_0 = self.input.LA(1)
2654
2655             if (LA12_0 == u'L' or LA12_0 == u'U' or LA12_0 == u'l' or LA12_0 == u'u') :
2656                 alt12 = 1
2657             if alt12 == 1:
2658                 # C.g:556:33: IntegerTypeSuffix
2659                 self.mIntegerTypeSuffix()
2660
2661
2662
2663
2664
2665
2666
2667
2668         finally:
2669
2670             pass
2671
2672     # $ANTLR end OCTAL_LITERAL
2673
2674
2675
2676     # $ANTLR start HexDigit
2677     def mHexDigit(self, ):
2678
2679         try:
2680             # C.g:559:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
2681             # C.g:559:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
2682             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'):
2683                 self.input.consume();
2684
2685             else:
2686                 mse = MismatchedSetException(None, self.input)
2687                 self.recover(mse)
2688                 raise mse
2689
2690
2691
2692
2693
2694
2695         finally:
2696
2697             pass
2698
2699     # $ANTLR end HexDigit
2700
2701
2702
2703     # $ANTLR start IntegerTypeSuffix
2704     def mIntegerTypeSuffix(self, ):
2705
2706         try:
2707             # C.g:563:2: ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) )
2708             alt13 = 4
2709             LA13_0 = self.input.LA(1)
2710
2711             if (LA13_0 == u'U' or LA13_0 == u'u') :
2712                 LA13_1 = self.input.LA(2)
2713
2714                 if (LA13_1 == u'L' or LA13_1 == u'l') :
2715                     LA13_3 = self.input.LA(3)
2716
2717                     if (LA13_3 == u'L' or LA13_3 == u'l') :
2718                         alt13 = 4
2719                     else:
2720                         alt13 = 3
2721                 else:
2722                     alt13 = 1
2723             elif (LA13_0 == u'L' or LA13_0 == u'l') :
2724                 alt13 = 2
2725             else:
2726                 nvae = NoViableAltException("561:1: fragment IntegerTypeSuffix : ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) );", 13, 0, self.input)
2727
2728                 raise nvae
2729
2730             if alt13 == 1:
2731                 # C.g:563:4: ( 'u' | 'U' )
2732                 if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
2733                     self.input.consume();
2734
2735                 else:
2736                     mse = MismatchedSetException(None, self.input)
2737                     self.recover(mse)
2738                     raise mse
2739
2740
2741
2742
2743             elif alt13 == 2:
2744                 # C.g:564:4: ( 'l' | 'L' )
2745                 if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2746                     self.input.consume();
2747
2748                 else:
2749                     mse = MismatchedSetException(None, self.input)
2750                     self.recover(mse)
2751                     raise mse
2752
2753
2754
2755
2756             elif alt13 == 3:
2757                 # C.g:565:4: ( 'u' | 'U' ) ( 'l' | 'L' )
2758                 if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
2759                     self.input.consume();
2760
2761                 else:
2762                     mse = MismatchedSetException(None, self.input)
2763                     self.recover(mse)
2764                     raise mse
2765
2766
2767                 if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2768                     self.input.consume();
2769
2770                 else:
2771                     mse = MismatchedSetException(None, self.input)
2772                     self.recover(mse)
2773                     raise mse
2774
2775
2776
2777
2778             elif alt13 == 4:
2779                 # C.g:566:4: ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' )
2780                 if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
2781                     self.input.consume();
2782
2783                 else:
2784                     mse = MismatchedSetException(None, self.input)
2785                     self.recover(mse)
2786                     raise mse
2787
2788
2789                 if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2790                     self.input.consume();
2791
2792                 else:
2793                     mse = MismatchedSetException(None, self.input)
2794                     self.recover(mse)
2795                     raise mse
2796
2797
2798                 if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2799                     self.input.consume();
2800
2801                 else:
2802                     mse = MismatchedSetException(None, self.input)
2803                     self.recover(mse)
2804                     raise mse
2805
2806
2807
2808
2809
2810         finally:
2811
2812             pass
2813
2814     # $ANTLR end IntegerTypeSuffix
2815
2816
2817
2818     # $ANTLR start FLOATING_POINT_LITERAL
2819     def mFLOATING_POINT_LITERAL(self, ):
2820
2821         try:
2822             self.type = FLOATING_POINT_LITERAL
2823
2824             # C.g:570:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix )
2825             alt25 = 4
2826             alt25 = self.dfa25.predict(self.input)
2827             if alt25 == 1:
2828                 # C.g:570:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )?
2829                 # C.g:570:9: ( '0' .. '9' )+
2830                 cnt14 = 0
2831                 while True: #loop14
2832                     alt14 = 2
2833                     LA14_0 = self.input.LA(1)
2834
2835                     if ((u'0' <= LA14_0 <= u'9')) :
2836                         alt14 = 1
2837
2838
2839                     if alt14 == 1:
2840                         # C.g:570:10: '0' .. '9'
2841                         self.matchRange(u'0', u'9')
2842
2843
2844
2845                     else:
2846                         if cnt14 >= 1:
2847                             break #loop14
2848
2849                         eee = EarlyExitException(14, self.input)
2850                         raise eee
2851
2852                     cnt14 += 1
2853
2854
2855                 self.match(u'.')
2856
2857                 # C.g:570:25: ( '0' .. '9' )*
2858                 while True: #loop15
2859                     alt15 = 2
2860                     LA15_0 = self.input.LA(1)
2861
2862                     if ((u'0' <= LA15_0 <= u'9')) :
2863                         alt15 = 1
2864
2865
2866                     if alt15 == 1:
2867                         # C.g:570:26: '0' .. '9'
2868                         self.matchRange(u'0', u'9')
2869
2870
2871
2872                     else:
2873                         break #loop15
2874
2875
2876                 # C.g:570:37: ( Exponent )?
2877                 alt16 = 2
2878                 LA16_0 = self.input.LA(1)
2879
2880                 if (LA16_0 == u'E' or LA16_0 == u'e') :
2881                     alt16 = 1
2882                 if alt16 == 1:
2883                     # C.g:570:37: Exponent
2884                     self.mExponent()
2885
2886
2887
2888
2889                 # C.g:570:47: ( FloatTypeSuffix )?
2890                 alt17 = 2
2891                 LA17_0 = self.input.LA(1)
2892
2893                 if (LA17_0 == u'D' or LA17_0 == u'F' or LA17_0 == u'd' or LA17_0 == u'f') :
2894                     alt17 = 1
2895                 if alt17 == 1:
2896                     # C.g:570:47: FloatTypeSuffix
2897                     self.mFloatTypeSuffix()
2898
2899
2900
2901
2902
2903
2904             elif alt25 == 2:
2905                 # C.g:571:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )?
2906                 self.match(u'.')
2907
2908                 # C.g:571:13: ( '0' .. '9' )+
2909                 cnt18 = 0
2910                 while True: #loop18
2911                     alt18 = 2
2912                     LA18_0 = self.input.LA(1)
2913
2914                     if ((u'0' <= LA18_0 <= u'9')) :
2915                         alt18 = 1
2916
2917
2918                     if alt18 == 1:
2919                         # C.g:571:14: '0' .. '9'
2920                         self.matchRange(u'0', u'9')
2921
2922
2923
2924                     else:
2925                         if cnt18 >= 1:
2926                             break #loop18
2927
2928                         eee = EarlyExitException(18, self.input)
2929                         raise eee
2930
2931                     cnt18 += 1
2932
2933
2934                 # C.g:571:25: ( Exponent )?
2935                 alt19 = 2
2936                 LA19_0 = self.input.LA(1)
2937
2938                 if (LA19_0 == u'E' or LA19_0 == u'e') :
2939                     alt19 = 1
2940                 if alt19 == 1:
2941                     # C.g:571:25: Exponent
2942                     self.mExponent()
2943
2944
2945
2946
2947                 # C.g:571:35: ( FloatTypeSuffix )?
2948                 alt20 = 2
2949                 LA20_0 = self.input.LA(1)
2950
2951                 if (LA20_0 == u'D' or LA20_0 == u'F' or LA20_0 == u'd' or LA20_0 == u'f') :
2952                     alt20 = 1
2953                 if alt20 == 1:
2954                     # C.g:571:35: FloatTypeSuffix
2955                     self.mFloatTypeSuffix()
2956
2957
2958
2959
2960
2961
2962             elif alt25 == 3:
2963                 # C.g:572:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )?
2964                 # C.g:572:9: ( '0' .. '9' )+
2965                 cnt21 = 0
2966                 while True: #loop21
2967                     alt21 = 2
2968                     LA21_0 = self.input.LA(1)
2969
2970                     if ((u'0' <= LA21_0 <= u'9')) :
2971                         alt21 = 1
2972
2973
2974                     if alt21 == 1:
2975                         # C.g:572:10: '0' .. '9'
2976                         self.matchRange(u'0', u'9')
2977
2978
2979
2980                     else:
2981                         if cnt21 >= 1:
2982                             break #loop21
2983
2984                         eee = EarlyExitException(21, self.input)
2985                         raise eee
2986
2987                     cnt21 += 1
2988
2989
2990                 self.mExponent()
2991
2992                 # C.g:572:30: ( FloatTypeSuffix )?
2993                 alt22 = 2
2994                 LA22_0 = self.input.LA(1)
2995
2996                 if (LA22_0 == u'D' or LA22_0 == u'F' or LA22_0 == u'd' or LA22_0 == u'f') :
2997                     alt22 = 1
2998                 if alt22 == 1:
2999                     # C.g:572:30: FloatTypeSuffix
3000                     self.mFloatTypeSuffix()
3001
3002
3003
3004
3005
3006
3007             elif alt25 == 4:
3008                 # C.g:573:9: ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix
3009                 # C.g:573:9: ( '0' .. '9' )+
3010                 cnt23 = 0
3011                 while True: #loop23
3012                     alt23 = 2
3013                     LA23_0 = self.input.LA(1)
3014
3015                     if ((u'0' <= LA23_0 <= u'9')) :
3016                         alt23 = 1
3017
3018
3019                     if alt23 == 1:
3020                         # C.g:573:10: '0' .. '9'
3021                         self.matchRange(u'0', u'9')
3022
3023
3024
3025                     else:
3026                         if cnt23 >= 1:
3027                             break #loop23
3028
3029                         eee = EarlyExitException(23, self.input)
3030                         raise eee
3031
3032                     cnt23 += 1
3033
3034
3035                 # C.g:573:21: ( Exponent )?
3036                 alt24 = 2
3037                 LA24_0 = self.input.LA(1)
3038
3039                 if (LA24_0 == u'E' or LA24_0 == u'e') :
3040                     alt24 = 1
3041                 if alt24 == 1:
3042                     # C.g:573:21: Exponent
3043                     self.mExponent()
3044
3045
3046
3047
3048                 self.mFloatTypeSuffix()
3049
3050
3051
3052
3053         finally:
3054
3055             pass
3056
3057     # $ANTLR end FLOATING_POINT_LITERAL
3058
3059
3060
3061     # $ANTLR start Exponent
3062     def mExponent(self, ):
3063
3064         try:
3065             # C.g:577:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
3066             # C.g:577:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
3067             if self.input.LA(1) == u'E' or self.input.LA(1) == u'e':
3068                 self.input.consume();
3069
3070             else:
3071                 mse = MismatchedSetException(None, self.input)
3072                 self.recover(mse)
3073                 raise mse
3074
3075
3076             # C.g:577:22: ( '+' | '-' )?
3077             alt26 = 2
3078             LA26_0 = self.input.LA(1)
3079
3080             if (LA26_0 == u'+' or LA26_0 == u'-') :
3081                 alt26 = 1
3082             if alt26 == 1:
3083                 # C.g:
3084                 if self.input.LA(1) == u'+' or self.input.LA(1) == u'-':
3085                     self.input.consume();
3086
3087                 else:
3088                     mse = MismatchedSetException(None, self.input)
3089                     self.recover(mse)
3090                     raise mse
3091
3092
3093
3094
3095
3096             # C.g:577:33: ( '0' .. '9' )+
3097             cnt27 = 0
3098             while True: #loop27
3099                 alt27 = 2
3100                 LA27_0 = self.input.LA(1)
3101
3102                 if ((u'0' <= LA27_0 <= u'9')) :
3103                     alt27 = 1
3104
3105
3106                 if alt27 == 1:
3107                     # C.g:577:34: '0' .. '9'
3108                     self.matchRange(u'0', u'9')
3109
3110
3111
3112                 else:
3113                     if cnt27 >= 1:
3114                         break #loop27
3115
3116                     eee = EarlyExitException(27, self.input)
3117                     raise eee
3118
3119                 cnt27 += 1
3120
3121
3122
3123
3124
3125
3126         finally:
3127
3128             pass
3129
3130     # $ANTLR end Exponent
3131
3132
3133
3134     # $ANTLR start FloatTypeSuffix
3135     def mFloatTypeSuffix(self, ):
3136
3137         try:
3138             # C.g:580:17: ( ( 'f' | 'F' | 'd' | 'D' ) )
3139             # C.g:580:19: ( 'f' | 'F' | 'd' | 'D' )
3140             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':
3141                 self.input.consume();
3142
3143             else:
3144                 mse = MismatchedSetException(None, self.input)
3145                 self.recover(mse)
3146                 raise mse
3147
3148
3149
3150
3151
3152
3153         finally:
3154
3155             pass
3156
3157     # $ANTLR end FloatTypeSuffix
3158
3159
3160
3161     # $ANTLR start EscapeSequence
3162     def mEscapeSequence(self, ):
3163
3164         try:
3165             # C.g:584:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape )
3166             alt28 = 2
3167             LA28_0 = self.input.LA(1)
3168
3169             if (LA28_0 == u'\\') :
3170                 LA28_1 = self.input.LA(2)
3171
3172                 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') :
3173                     alt28 = 1
3174                 elif ((u'0' <= LA28_1 <= u'7')) :
3175                     alt28 = 2
3176                 else:
3177                     nvae = NoViableAltException("582:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 1, self.input)
3178
3179                     raise nvae
3180
3181             else:
3182                 nvae = NoViableAltException("582:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 0, self.input)
3183
3184                 raise nvae
3185
3186             if alt28 == 1:
3187                 # C.g:584:8: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
3188                 self.match(u'\\')
3189
3190                 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':
3191                     self.input.consume();
3192
3193                 else:
3194                     mse = MismatchedSetException(None, self.input)
3195                     self.recover(mse)
3196                     raise mse
3197
3198
3199
3200
3201             elif alt28 == 2:
3202                 # C.g:585:9: OctalEscape
3203                 self.mOctalEscape()
3204
3205
3206
3207
3208         finally:
3209
3210             pass
3211
3212     # $ANTLR end EscapeSequence
3213
3214
3215
3216     # $ANTLR start OctalEscape
3217     def mOctalEscape(self, ):
3218
3219         try:
3220             # C.g:590:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
3221             alt29 = 3
3222             LA29_0 = self.input.LA(1)
3223
3224             if (LA29_0 == u'\\') :
3225                 LA29_1 = self.input.LA(2)
3226
3227                 if ((u'0' <= LA29_1 <= u'3')) :
3228                     LA29_2 = self.input.LA(3)
3229
3230                     if ((u'0' <= LA29_2 <= u'7')) :
3231                         LA29_4 = self.input.LA(4)
3232
3233                         if ((u'0' <= LA29_4 <= u'7')) :
3234                             alt29 = 1
3235                         else:
3236                             alt29 = 2
3237                     else:
3238                         alt29 = 3
3239                 elif ((u'4' <= LA29_1 <= u'7')) :
3240                     LA29_3 = self.input.LA(3)
3241
3242                     if ((u'0' <= LA29_3 <= u'7')) :
3243                         alt29 = 2
3244                     else:
3245                         alt29 = 3
3246                 else:
3247                     nvae = NoViableAltException("588:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 1, self.input)
3248
3249                     raise nvae
3250
3251             else:
3252                 nvae = NoViableAltException("588:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 0, self.input)
3253
3254                 raise nvae
3255
3256             if alt29 == 1:
3257                 # C.g:590:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
3258                 self.match(u'\\')
3259
3260                 # C.g:590:14: ( '0' .. '3' )
3261                 # C.g:590:15: '0' .. '3'
3262                 self.matchRange(u'0', u'3')
3263
3264
3265
3266
3267                 # C.g:590:25: ( '0' .. '7' )
3268                 # C.g:590:26: '0' .. '7'
3269                 self.matchRange(u'0', u'7')
3270
3271
3272
3273
3274                 # C.g:590:36: ( '0' .. '7' )
3275                 # C.g:590:37: '0' .. '7'
3276                 self.matchRange(u'0', u'7')
3277
3278
3279
3280
3281
3282
3283             elif alt29 == 2:
3284                 # C.g:591:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
3285                 self.match(u'\\')
3286
3287                 # C.g:591:14: ( '0' .. '7' )
3288                 # C.g:591:15: '0' .. '7'
3289                 self.matchRange(u'0', u'7')
3290
3291
3292
3293
3294                 # C.g:591:25: ( '0' .. '7' )
3295                 # C.g:591:26: '0' .. '7'
3296                 self.matchRange(u'0', u'7')
3297
3298
3299
3300
3301
3302
3303             elif alt29 == 3:
3304                 # C.g:592:9: '\\\\' ( '0' .. '7' )
3305                 self.match(u'\\')
3306
3307                 # C.g:592:14: ( '0' .. '7' )
3308                 # C.g:592:15: '0' .. '7'
3309                 self.matchRange(u'0', u'7')
3310
3311
3312
3313
3314
3315
3316
3317         finally:
3318
3319             pass
3320
3321     # $ANTLR end OctalEscape
3322
3323
3324
3325     # $ANTLR start UnicodeEscape
3326     def mUnicodeEscape(self, ):
3327
3328         try:
3329             # C.g:597:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )
3330             # C.g:597:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit
3331             self.match(u'\\')
3332
3333             self.match(u'u')
3334
3335             self.mHexDigit()
3336
3337             self.mHexDigit()
3338
3339             self.mHexDigit()
3340
3341             self.mHexDigit()
3342
3343
3344
3345
3346
3347         finally:
3348
3349             pass
3350
3351     # $ANTLR end UnicodeEscape
3352
3353
3354
3355     # $ANTLR start WS
3356     def mWS(self, ):
3357
3358         try:
3359             self.type = WS
3360
3361             # C.g:600:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
3362             # C.g:600:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
3363             if (u'\t' <= self.input.LA(1) <= u'\n') or (u'\f' <= self.input.LA(1) <= u'\r') or self.input.LA(1) == u' ':
3364                 self.input.consume();
3365
3366             else:
3367                 mse = MismatchedSetException(None, self.input)
3368                 self.recover(mse)
3369                 raise mse
3370
3371
3372             #action start
3373             self.channel=HIDDEN;
3374             #action end
3375
3376
3377
3378
3379         finally:
3380
3381             pass
3382
3383     # $ANTLR end WS
3384
3385
3386
3387     # $ANTLR start BS
3388     def mBS(self, ):
3389
3390         try:
3391             self.type = BS
3392
3393             # C.g:604:5: ( ( '\\\\' ) )
3394             # C.g:604:7: ( '\\\\' )
3395             # C.g:604:7: ( '\\\\' )
3396             # C.g:604:8: '\\\\'
3397             self.match(u'\\')
3398
3399
3400
3401
3402             #action start
3403             self.channel=HIDDEN;
3404             #action end
3405
3406
3407
3408
3409         finally:
3410
3411             pass
3412
3413     # $ANTLR end BS
3414
3415
3416
3417     # $ANTLR start UnicodeVocabulary
3418     def mUnicodeVocabulary(self, ):
3419
3420         try:
3421             self.type = UnicodeVocabulary
3422
3423             # C.g:612:5: ( '\\u0003' .. '\\uFFFE' )
3424             # C.g:612:7: '\\u0003' .. '\\uFFFE'
3425             self.matchRange(u'\u0003', u'\uFFFE')
3426
3427
3428
3429
3430
3431         finally:
3432
3433             pass
3434
3435     # $ANTLR end UnicodeVocabulary
3436
3437
3438
3439     # $ANTLR start COMMENT
3440     def mCOMMENT(self, ):
3441
3442         try:
3443             self.type = COMMENT
3444
3445             # C.g:615:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
3446             # C.g:615:9: '/*' ( options {greedy=false; } : . )* '*/'
3447             self.match("/*")
3448
3449
3450             # C.g:615:14: ( options {greedy=false; } : . )*
3451             while True: #loop30
3452                 alt30 = 2
3453                 LA30_0 = self.input.LA(1)
3454
3455                 if (LA30_0 == u'*') :
3456                     LA30_1 = self.input.LA(2)
3457
3458                     if (LA30_1 == u'/') :
3459                         alt30 = 2
3460                     elif ((u'\u0000' <= LA30_1 <= u'.') or (u'0' <= LA30_1 <= u'\uFFFE')) :
3461                         alt30 = 1
3462
3463
3464                 elif ((u'\u0000' <= LA30_0 <= u')') or (u'+' <= LA30_0 <= u'\uFFFE')) :
3465                     alt30 = 1
3466
3467
3468                 if alt30 == 1:
3469                     # C.g:615:42: .
3470                     self.matchAny()
3471
3472
3473
3474                 else:
3475                     break #loop30
3476
3477
3478             self.match("*/")
3479
3480
3481             #action start
3482             self.channel=HIDDEN;
3483             #action end
3484
3485
3486
3487
3488         finally:
3489
3490             pass
3491
3492     # $ANTLR end COMMENT
3493
3494
3495
3496     # $ANTLR start LINE_COMMENT
3497     def mLINE_COMMENT(self, ):
3498
3499         try:
3500             self.type = LINE_COMMENT
3501
3502             # C.g:620:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
3503             # C.g:620:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
3504             self.match("//")
3505
3506
3507             # C.g:620:12: (~ ( '\\n' | '\\r' ) )*
3508             while True: #loop31
3509                 alt31 = 2
3510                 LA31_0 = self.input.LA(1)
3511
3512                 if ((u'\u0000' <= LA31_0 <= u'\t') or (u'\u000B' <= LA31_0 <= u'\f') or (u'\u000E' <= LA31_0 <= u'\uFFFE')) :
3513                     alt31 = 1
3514
3515
3516                 if alt31 == 1:
3517                     # C.g:620:12: ~ ( '\\n' | '\\r' )
3518                     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'):
3519                         self.input.consume();
3520
3521                     else:
3522                         mse = MismatchedSetException(None, self.input)
3523                         self.recover(mse)
3524                         raise mse
3525
3526
3527
3528
3529                 else:
3530                     break #loop31
3531
3532
3533             # C.g:620:26: ( '\\r' )?
3534             alt32 = 2
3535             LA32_0 = self.input.LA(1)
3536
3537             if (LA32_0 == u'\r') :
3538                 alt32 = 1
3539             if alt32 == 1:
3540                 # C.g:620:26: '\\r'
3541                 self.match(u'\r')
3542
3543
3544
3545
3546             self.match(u'\n')
3547
3548             #action start
3549             self.channel=HIDDEN;
3550             #action end
3551
3552
3553
3554
3555         finally:
3556
3557             pass
3558
3559     # $ANTLR end LINE_COMMENT
3560
3561
3562
3563     # $ANTLR start LINE_COMMAND
3564     def mLINE_COMMAND(self, ):
3565
3566         try:
3567             self.type = LINE_COMMAND
3568
3569             # C.g:625:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
3570             # C.g:625:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
3571             self.match(u'#')
3572
3573             # C.g:625:11: (~ ( '\\n' | '\\r' ) )*
3574             while True: #loop33
3575                 alt33 = 2
3576                 LA33_0 = self.input.LA(1)
3577
3578                 if ((u'\u0000' <= LA33_0 <= u'\t') or (u'\u000B' <= LA33_0 <= u'\f') or (u'\u000E' <= LA33_0 <= u'\uFFFE')) :
3579                     alt33 = 1
3580
3581
3582                 if alt33 == 1:
3583                     # C.g:625:11: ~ ( '\\n' | '\\r' )
3584                     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'):
3585                         self.input.consume();
3586
3587                     else:
3588                         mse = MismatchedSetException(None, self.input)
3589                         self.recover(mse)
3590                         raise mse
3591
3592
3593
3594
3595                 else:
3596                     break #loop33
3597
3598
3599             # C.g:625:25: ( '\\r' )?
3600             alt34 = 2
3601             LA34_0 = self.input.LA(1)
3602
3603             if (LA34_0 == u'\r') :
3604                 alt34 = 1
3605             if alt34 == 1:
3606                 # C.g:625:25: '\\r'
3607                 self.match(u'\r')
3608
3609
3610
3611
3612             self.match(u'\n')
3613
3614             #action start
3615             self.channel=HIDDEN;
3616             #action end
3617
3618
3619
3620
3621         finally:
3622
3623             pass
3624
3625     # $ANTLR end LINE_COMMAND
3626
3627
3628
3629     def mTokens(self):
3630         # 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 | T116 | IDENTIFIER | CHARACTER_LITERAL | STRING_LITERAL | HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOATING_POINT_LITERAL | WS | BS | UnicodeVocabulary | COMMENT | LINE_COMMENT | LINE_COMMAND )
3631         alt35 = 105
3632         alt35 = self.dfa35.predict(self.input)
3633         if alt35 == 1:
3634             # C.g:1:10: T25
3635             self.mT25()
3636
3637
3638
3639         elif alt35 == 2:
3640             # C.g:1:14: T26
3641             self.mT26()
3642
3643
3644
3645         elif alt35 == 3:
3646             # C.g:1:18: T27
3647             self.mT27()
3648
3649
3650
3651         elif alt35 == 4:
3652             # C.g:1:22: T28
3653             self.mT28()
3654
3655
3656
3657         elif alt35 == 5:
3658             # C.g:1:26: T29
3659             self.mT29()
3660
3661
3662
3663         elif alt35 == 6:
3664             # C.g:1:30: T30
3665             self.mT30()
3666
3667
3668
3669         elif alt35 == 7:
3670             # C.g:1:34: T31
3671             self.mT31()
3672
3673
3674
3675         elif alt35 == 8:
3676             # C.g:1:38: T32
3677             self.mT32()
3678
3679
3680
3681         elif alt35 == 9:
3682             # C.g:1:42: T33
3683             self.mT33()
3684
3685
3686
3687         elif alt35 == 10:
3688             # C.g:1:46: T34
3689             self.mT34()
3690
3691
3692
3693         elif alt35 == 11:
3694             # C.g:1:50: T35
3695             self.mT35()
3696
3697
3698
3699         elif alt35 == 12:
3700             # C.g:1:54: T36
3701             self.mT36()
3702
3703
3704
3705         elif alt35 == 13:
3706             # C.g:1:58: T37
3707             self.mT37()
3708
3709
3710
3711         elif alt35 == 14:
3712             # C.g:1:62: T38
3713             self.mT38()
3714
3715
3716
3717         elif alt35 == 15:
3718             # C.g:1:66: T39
3719             self.mT39()
3720
3721
3722
3723         elif alt35 == 16:
3724             # C.g:1:70: T40
3725             self.mT40()
3726
3727
3728
3729         elif alt35 == 17:
3730             # C.g:1:74: T41
3731             self.mT41()
3732
3733
3734
3735         elif alt35 == 18:
3736             # C.g:1:78: T42
3737             self.mT42()
3738
3739
3740
3741         elif alt35 == 19:
3742             # C.g:1:82: T43
3743             self.mT43()
3744
3745
3746
3747         elif alt35 == 20:
3748             # C.g:1:86: T44
3749             self.mT44()
3750
3751
3752
3753         elif alt35 == 21:
3754             # C.g:1:90: T45
3755             self.mT45()
3756
3757
3758
3759         elif alt35 == 22:
3760             # C.g:1:94: T46
3761             self.mT46()
3762
3763
3764
3765         elif alt35 == 23:
3766             # C.g:1:98: T47
3767             self.mT47()
3768
3769
3770
3771         elif alt35 == 24:
3772             # C.g:1:102: T48
3773             self.mT48()
3774
3775
3776
3777         elif alt35 == 25:
3778             # C.g:1:106: T49
3779             self.mT49()
3780
3781
3782
3783         elif alt35 == 26:
3784             # C.g:1:110: T50
3785             self.mT50()
3786
3787
3788
3789         elif alt35 == 27:
3790             # C.g:1:114: T51
3791             self.mT51()
3792
3793
3794
3795         elif alt35 == 28:
3796             # C.g:1:118: T52
3797             self.mT52()
3798
3799
3800
3801         elif alt35 == 29:
3802             # C.g:1:122: T53
3803             self.mT53()
3804
3805
3806
3807         elif alt35 == 30:
3808             # C.g:1:126: T54
3809             self.mT54()
3810
3811
3812
3813         elif alt35 == 31:
3814             # C.g:1:130: T55
3815             self.mT55()
3816
3817
3818
3819         elif alt35 == 32:
3820             # C.g:1:134: T56
3821             self.mT56()
3822
3823
3824
3825         elif alt35 == 33:
3826             # C.g:1:138: T57
3827             self.mT57()
3828
3829
3830
3831         elif alt35 == 34:
3832             # C.g:1:142: T58
3833             self.mT58()
3834
3835
3836
3837         elif alt35 == 35:
3838             # C.g:1:146: T59
3839             self.mT59()
3840
3841
3842
3843         elif alt35 == 36:
3844             # C.g:1:150: T60
3845             self.mT60()
3846
3847
3848
3849         elif alt35 == 37:
3850             # C.g:1:154: T61
3851             self.mT61()
3852
3853
3854
3855         elif alt35 == 38:
3856             # C.g:1:158: T62
3857             self.mT62()
3858
3859
3860
3861         elif alt35 == 39:
3862             # C.g:1:162: T63
3863             self.mT63()
3864
3865
3866
3867         elif alt35 == 40:
3868             # C.g:1:166: T64
3869             self.mT64()
3870
3871
3872
3873         elif alt35 == 41:
3874             # C.g:1:170: T65
3875             self.mT65()
3876
3877
3878
3879         elif alt35 == 42:
3880             # C.g:1:174: T66
3881             self.mT66()
3882
3883
3884
3885         elif alt35 == 43:
3886             # C.g:1:178: T67
3887             self.mT67()
3888
3889
3890
3891         elif alt35 == 44:
3892             # C.g:1:182: T68
3893             self.mT68()
3894
3895
3896
3897         elif alt35 == 45:
3898             # C.g:1:186: T69
3899             self.mT69()
3900
3901
3902
3903         elif alt35 == 46:
3904             # C.g:1:190: T70
3905             self.mT70()
3906
3907
3908
3909         elif alt35 == 47:
3910             # C.g:1:194: T71
3911             self.mT71()
3912
3913
3914
3915         elif alt35 == 48:
3916             # C.g:1:198: T72
3917             self.mT72()
3918
3919
3920
3921         elif alt35 == 49:
3922             # C.g:1:202: T73
3923             self.mT73()
3924
3925
3926
3927         elif alt35 == 50:
3928             # C.g:1:206: T74
3929             self.mT74()
3930
3931
3932
3933         elif alt35 == 51:
3934             # C.g:1:210: T75
3935             self.mT75()
3936
3937
3938
3939         elif alt35 == 52:
3940             # C.g:1:214: T76
3941             self.mT76()
3942
3943
3944
3945         elif alt35 == 53:
3946             # C.g:1:218: T77
3947             self.mT77()
3948
3949
3950
3951         elif alt35 == 54:
3952             # C.g:1:222: T78
3953             self.mT78()
3954
3955
3956
3957         elif alt35 == 55:
3958             # C.g:1:226: T79
3959             self.mT79()
3960
3961
3962
3963         elif alt35 == 56:
3964             # C.g:1:230: T80
3965             self.mT80()
3966
3967
3968
3969         elif alt35 == 57:
3970             # C.g:1:234: T81
3971             self.mT81()
3972
3973
3974
3975         elif alt35 == 58:
3976             # C.g:1:238: T82
3977             self.mT82()
3978
3979
3980
3981         elif alt35 == 59:
3982             # C.g:1:242: T83
3983             self.mT83()
3984
3985
3986
3987         elif alt35 == 60:
3988             # C.g:1:246: T84
3989             self.mT84()
3990
3991
3992
3993         elif alt35 == 61:
3994             # C.g:1:250: T85
3995             self.mT85()
3996
3997
3998
3999         elif alt35 == 62:
4000             # C.g:1:254: T86
4001             self.mT86()
4002
4003
4004
4005         elif alt35 == 63:
4006             # C.g:1:258: T87
4007             self.mT87()
4008
4009
4010
4011         elif alt35 == 64:
4012             # C.g:1:262: T88
4013             self.mT88()
4014
4015
4016
4017         elif alt35 == 65:
4018             # C.g:1:266: T89
4019             self.mT89()
4020
4021
4022
4023         elif alt35 == 66:
4024             # C.g:1:270: T90
4025             self.mT90()
4026
4027
4028
4029         elif alt35 == 67:
4030             # C.g:1:274: T91
4031             self.mT91()
4032
4033
4034
4035         elif alt35 == 68:
4036             # C.g:1:278: T92
4037             self.mT92()
4038
4039
4040
4041         elif alt35 == 69:
4042             # C.g:1:282: T93
4043             self.mT93()
4044
4045
4046
4047         elif alt35 == 70:
4048             # C.g:1:286: T94
4049             self.mT94()
4050
4051
4052
4053         elif alt35 == 71:
4054             # C.g:1:290: T95
4055             self.mT95()
4056
4057
4058
4059         elif alt35 == 72:
4060             # C.g:1:294: T96
4061             self.mT96()
4062
4063
4064
4065         elif alt35 == 73:
4066             # C.g:1:298: T97
4067             self.mT97()
4068
4069
4070
4071         elif alt35 == 74:
4072             # C.g:1:302: T98
4073             self.mT98()
4074
4075
4076
4077         elif alt35 == 75:
4078             # C.g:1:306: T99
4079             self.mT99()
4080
4081
4082
4083         elif alt35 == 76:
4084             # C.g:1:310: T100
4085             self.mT100()
4086
4087
4088
4089         elif alt35 == 77:
4090             # C.g:1:315: T101
4091             self.mT101()
4092
4093
4094
4095         elif alt35 == 78:
4096             # C.g:1:320: T102
4097             self.mT102()
4098
4099
4100
4101         elif alt35 == 79:
4102             # C.g:1:325: T103
4103             self.mT103()
4104
4105
4106
4107         elif alt35 == 80:
4108             # C.g:1:330: T104
4109             self.mT104()
4110
4111
4112
4113         elif alt35 == 81:
4114             # C.g:1:335: T105
4115             self.mT105()
4116
4117
4118
4119         elif alt35 == 82:
4120             # C.g:1:340: T106
4121             self.mT106()
4122
4123
4124
4125         elif alt35 == 83:
4126             # C.g:1:345: T107
4127             self.mT107()
4128
4129
4130
4131         elif alt35 == 84:
4132             # C.g:1:350: T108
4133             self.mT108()
4134
4135
4136
4137         elif alt35 == 85:
4138             # C.g:1:355: T109
4139             self.mT109()
4140
4141
4142
4143         elif alt35 == 86:
4144             # C.g:1:360: T110
4145             self.mT110()
4146
4147
4148
4149         elif alt35 == 87:
4150             # C.g:1:365: T111
4151             self.mT111()
4152
4153
4154
4155         elif alt35 == 88:
4156             # C.g:1:370: T112
4157             self.mT112()
4158
4159
4160
4161         elif alt35 == 89:
4162             # C.g:1:375: T113
4163             self.mT113()
4164
4165
4166
4167         elif alt35 == 90:
4168             # C.g:1:380: T114
4169             self.mT114()
4170
4171
4172
4173         elif alt35 == 91:
4174             # C.g:1:385: T115
4175             self.mT115()
4176
4177
4178
4179         elif alt35 == 92:
4180             # C.g:1:390: T116
4181             self.mT116()
4182
4183
4184
4185         elif alt35 == 93:
4186             # C.g:1:395: IDENTIFIER
4187             self.mIDENTIFIER()
4188
4189
4190
4191         elif alt35 == 94:
4192             # C.g:1:406: CHARACTER_LITERAL
4193             self.mCHARACTER_LITERAL()
4194
4195
4196
4197         elif alt35 == 95:
4198             # C.g:1:424: STRING_LITERAL
4199             self.mSTRING_LITERAL()
4200
4201
4202
4203         elif alt35 == 96:
4204             # C.g:1:439: HEX_LITERAL
4205             self.mHEX_LITERAL()
4206
4207
4208
4209         elif alt35 == 97:
4210             # C.g:1:451: DECIMAL_LITERAL
4211             self.mDECIMAL_LITERAL()
4212
4213
4214
4215         elif alt35 == 98:
4216             # C.g:1:467: OCTAL_LITERAL
4217             self.mOCTAL_LITERAL()
4218
4219
4220
4221         elif alt35 == 99:
4222             # C.g:1:481: FLOATING_POINT_LITERAL
4223             self.mFLOATING_POINT_LITERAL()
4224
4225
4226
4227         elif alt35 == 100:
4228             # C.g:1:504: WS
4229             self.mWS()
4230
4231
4232
4233         elif alt35 == 101:
4234             # C.g:1:507: BS
4235             self.mBS()
4236
4237
4238
4239         elif alt35 == 102:
4240             # C.g:1:510: UnicodeVocabulary
4241             self.mUnicodeVocabulary()
4242
4243
4244
4245         elif alt35 == 103:
4246             # C.g:1:528: COMMENT
4247             self.mCOMMENT()
4248
4249
4250
4251         elif alt35 == 104:
4252             # C.g:1:536: LINE_COMMENT
4253             self.mLINE_COMMENT()
4254
4255
4256
4257         elif alt35 == 105:
4258             # C.g:1:549: LINE_COMMAND
4259             self.mLINE_COMMAND()
4260
4261
4262
4263
4264
4265
4266
4267
4268     # lookup tables for DFA #25
4269
4270     DFA25_eot = DFA.unpack(
4271         u"\7\uffff\1\10\2\uffff"
4272         )
4273
4274     DFA25_eof = DFA.unpack(
4275         u"\12\uffff"
4276         )
4277
4278     DFA25_min = DFA.unpack(
4279         u"\2\56\1\uffff\1\53\2\uffff\2\60\2\uffff"
4280         )
4281
4282     DFA25_max = DFA.unpack(
4283         u"\1\71\1\146\1\uffff\1\71\2\uffff\1\71\1\146\2\uffff"
4284         )
4285
4286     DFA25_accept = DFA.unpack(
4287         u"\2\uffff\1\2\1\uffff\1\4\1\1\2\uffff\2\3"
4288         )
4289
4290     DFA25_special = DFA.unpack(
4291         u"\12\uffff"
4292         )
4293
4294
4295     DFA25_transition = [
4296         DFA.unpack(u"\1\2\1\uffff\12\1"),
4297         DFA.unpack(u"\1\5\1\uffff\12\1\12\uffff\1\4\1\3\1\4\35\uffff\1\4"
4298         u"\1\3\1\4"),
4299         DFA.unpack(u""),
4300         DFA.unpack(u"\1\6\1\uffff\1\6\2\uffff\12\7"),
4301         DFA.unpack(u""),
4302         DFA.unpack(u""),
4303         DFA.unpack(u"\12\7"),
4304         DFA.unpack(u"\12\7\12\uffff\1\11\1\uffff\1\11\35\uffff\1\11\1\uffff"
4305         u"\1\11"),
4306         DFA.unpack(u""),
4307         DFA.unpack(u"")
4308     ]
4309
4310     # class definition for DFA #25
4311
4312     DFA25 = DFA
4313     # lookup tables for DFA #35
4314
4315     DFA35_eot = DFA.unpack(
4316         u"\2\uffff\1\75\1\uffff\1\100\14\75\3\uffff\7\75\4\uffff\1\147\1"
4317         u"\151\1\155\1\161\1\165\1\167\1\172\1\uffff\1\175\1\u0080\1\u0083"
4318         u"\1\u0085\1\u0088\1\uffff\5\75\1\uffff\2\72\2\u0092\2\uffff\1\72"
4319         u"\2\uffff\1\75\4\uffff\16\75\1\u00ab\4\75\1\u00b1\2\75\3\uffff\1"
4320         u"\u00b5\7\75\35\uffff\1\u00be\1\uffff\1\u00c0\10\uffff\5\75\4\uffff"
4321         u"\1\u00c6\1\u0092\3\uffff\23\75\1\uffff\1\u00db\1\75\1\u00dd\2\75"
4322         u"\1\uffff\3\75\1\uffff\1\u00e3\6\75\4\uffff\5\75\1\uffff\1\75\1"
4323         u"\u00f1\1\u00f2\7\75\1\u00fa\3\75\1\u00fe\3\75\1\u0102\1\u0103\1"
4324         u"\uffff\1\u0104\1\uffff\5\75\1\uffff\10\75\1\u0113\1\75\1\u0115"
4325         u"\2\75\2\uffff\6\75\1\u011e\1\uffff\3\75\1\uffff\2\75\1\u0124\3"
4326         u"\uffff\1\u0125\3\75\1\u0129\1\75\1\u012b\6\75\1\u0133\1\uffff\1"
4327         u"\u0134\1\uffff\1\u0135\1\75\1\u0137\1\u0138\1\u0139\1\u013a\1\u013b"
4328         u"\1\u013c\1\uffff\1\75\1\u013e\1\u013f\2\75\2\uffff\1\u0142\2\75"
4329         u"\1\uffff\1\75\1\uffff\5\75\1\u014b\1\75\3\uffff\1\u014d\6\uffff"
4330         u"\1\75\2\uffff\2\75\1\uffff\1\u0151\7\75\1\uffff\1\u0159\1\uffff"
4331         u"\1\u015a\1\u015b\1\u015c\1\uffff\1\u015d\1\u015e\1\75\1\u0160\3"
4332         u"\75\6\uffff\1\u0164\1\uffff\3\75\1\uffff\20\75\1\u0178\2\75\1\uffff"
4333         u"\4\75\1\u017f\1\75\1\uffff\11\75\1\u018a\1\uffff"
4334         )
4335
4336     DFA35_eof = DFA.unpack(
4337         u"\u018b\uffff"
4338         )
4339
4340     DFA35_min = DFA.unpack(
4341         u"\1\3\1\uffff\1\171\1\uffff\1\75\1\154\1\150\1\165\1\145\1\124\1"
4342         u"\157\1\141\1\146\1\157\1\154\1\145\1\156\3\uffff\1\116\1\120\1"
4343         u"\117\1\116\1\117\1\114\1\106\4\uffff\1\75\1\56\1\53\1\55\1\52\1"
4344         u"\75\1\46\1\uffff\1\75\1\74\3\75\1\uffff\1\137\1\150\1\157\1\162"
4345         u"\1\42\1\uffff\2\0\2\56\2\uffff\1\0\2\uffff\1\160\4\uffff\1\165"
4346         u"\1\163\1\164\1\141\1\151\1\147\1\157\1\164\1\147\1\101\1\151\1"
4347         u"\156\1\163\1\141\1\44\1\164\1\156\1\162\1\157\1\44\1\146\1\151"
4348         u"\3\uffff\1\44\2\124\1\116\1\101\1\114\1\117\1\111\35\uffff\1\75"
4349         u"\1\uffff\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\4\uffff\2"
4350         u"\56\3\uffff\1\145\1\155\2\145\1\165\2\164\1\156\1\145\1\162\1\157"
4351         u"\1\151\1\165\1\124\1\144\1\141\1\163\1\145\1\162\1\uffff\1\44\1"
4352         u"\147\1\44\1\141\1\142\1\uffff\1\141\1\151\1\157\1\uffff\1\44\1"
4353         u"\111\1\123\1\114\1\101\1\102\1\101\4\uffff\1\163\1\155\1\154\1"
4354         u"\157\1\141\1\uffff\1\144\2\44\1\162\1\143\1\151\1\143\1\145\1\157"
4355         u"\1\164\1\44\1\163\1\162\1\111\1\44\1\164\1\151\1\164\2\44\1\uffff"
4356         u"\1\44\1\uffff\1\164\1\154\1\165\1\147\1\156\1\uffff\1\117\1\124"
4357         u"\1\111\1\124\1\101\1\102\1\120\1\155\1\44\1\145\1\44\1\153\1\145"
4358         u"\2\uffff\1\156\1\164\1\143\1\150\1\144\1\146\1\44\1\uffff\1\164"
4359         u"\1\156\1\103\1\uffff\1\151\1\156\1\44\3\uffff\1\44\1\145\1\154"
4360         u"\1\156\1\44\1\116\1\44\1\107\1\111\1\114\1\117\1\125\1\111\1\44"
4361         u"\1\uffff\1\44\1\uffff\1\44\1\146\6\44\1\uffff\1\145\2\44\1\154"
4362         u"\1\165\2\uffff\1\44\1\164\1\145\1\uffff\1\101\1\uffff\1\116\1\114"
4363         u"\1\137\1\117\1\116\1\44\1\137\3\uffff\1\44\6\uffff\1\162\2\uffff"
4364         u"\2\145\1\uffff\1\44\1\144\1\114\2\105\1\122\2\124\1\uffff\1\44"
4365         u"\1\uffff\3\44\1\uffff\2\44\1\104\1\44\1\105\1\123\1\111\6\uffff"
4366         u"\1\44\1\uffff\1\115\1\105\1\115\1\uffff\1\117\1\122\1\105\2\126"
4367         u"\1\123\1\105\1\111\1\105\1\137\1\103\1\122\1\111\1\105\1\126\1"
4368         u"\106\1\44\1\111\1\137\1\uffff\1\103\1\125\1\105\1\116\1\44\1\122"
4369         u"\1\uffff\1\105\1\106\1\105\1\122\1\105\1\116\1\103\1\105\1\104"
4370         u"\1\44\1\uffff"
4371         )
4372
4373     DFA35_max = DFA.unpack(
4374         u"\1\ufffe\1\uffff\1\171\1\uffff\1\75\1\170\1\167\1\165\1\145\1\124"
4375         u"\2\157\1\156\3\157\1\156\3\uffff\1\116\1\125\1\117\1\116\1\117"
4376         u"\1\114\1\106\4\uffff\1\75\1\71\1\75\1\76\3\75\1\uffff\2\75\1\76"
4377         u"\1\75\1\174\1\uffff\1\141\1\150\1\157\1\162\1\47\1\uffff\2\ufffe"
4378         u"\1\170\1\146\2\uffff\1\ufffe\2\uffff\1\160\4\uffff\1\165\1\163"
4379         u"\1\164\1\162\1\151\1\172\1\157\2\164\1\101\1\154\1\156\1\163\1"
4380         u"\141\1\172\1\164\1\156\1\162\1\157\1\172\1\146\1\163\3\uffff\1"
4381         u"\172\2\124\1\116\1\101\1\114\1\117\1\111\35\uffff\1\75\1\uffff"
4382         u"\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\4\uffff\2\146\3\uffff"
4383         u"\1\145\1\155\2\145\1\165\2\164\1\156\1\145\1\162\1\157\1\151\1"
4384         u"\165\1\124\1\144\1\141\1\164\1\145\1\162\1\uffff\1\172\1\147\1"
4385         u"\172\1\141\1\142\1\uffff\1\141\1\151\1\157\1\uffff\1\172\1\111"
4386         u"\1\123\1\114\1\101\1\102\1\137\4\uffff\1\163\1\155\1\154\1\157"
4387         u"\1\141\1\uffff\1\144\2\172\1\162\1\143\1\151\1\143\1\145\1\157"
4388         u"\1\164\1\172\1\163\1\162\1\111\1\172\1\164\1\151\1\164\2\172\1"
4389         u"\uffff\1\172\1\uffff\1\164\1\154\1\165\1\147\1\156\1\uffff\1\117"
4390         u"\1\124\1\111\1\124\1\101\1\122\1\120\1\155\1\172\1\145\1\172\1"
4391         u"\153\1\145\2\uffff\1\156\1\164\1\143\1\150\1\144\1\146\1\172\1"
4392         u"\uffff\1\164\1\156\1\103\1\uffff\1\151\1\156\1\172\3\uffff\1\172"
4393         u"\1\145\1\154\1\156\1\172\1\116\1\172\1\107\1\111\1\114\1\117\1"
4394         u"\125\1\111\1\172\1\uffff\1\172\1\uffff\1\172\1\146\6\172\1\uffff"
4395         u"\1\145\2\172\1\154\1\165\2\uffff\1\172\1\164\1\145\1\uffff\1\101"
4396         u"\1\uffff\1\116\1\114\1\137\1\117\1\116\1\172\1\137\3\uffff\1\172"
4397         u"\6\uffff\1\162\2\uffff\2\145\1\uffff\1\172\1\144\1\114\2\105\1"
4398         u"\122\2\124\1\uffff\1\172\1\uffff\3\172\1\uffff\2\172\1\104\1\172"
4399         u"\1\105\1\123\1\111\6\uffff\1\172\1\uffff\1\115\1\105\1\115\1\uffff"
4400         u"\1\117\1\122\1\105\2\126\1\123\1\105\1\111\1\105\1\137\1\103\1"
4401         u"\122\1\111\1\105\1\126\1\106\1\172\1\111\1\137\1\uffff\1\103\1"
4402         u"\125\1\105\1\116\1\172\1\122\1\uffff\1\105\1\106\1\105\1\122\1"
4403         u"\105\1\116\1\103\1\105\1\104\1\172\1\uffff"
4404         )
4405
4406     DFA35_accept = DFA.unpack(
4407         u"\1\uffff\1\1\1\uffff\1\3\15\uffff\1\23\1\24\1\27\7\uffff\1\45\1"
4408         u"\46\1\47\1\50\7\uffff\1\65\5\uffff\1\101\5\uffff\1\135\4\uffff"
4409         u"\1\144\1\145\1\uffff\1\146\1\1\1\uffff\1\135\1\3\1\106\1\4\26\uffff"
4410         u"\1\23\1\24\1\27\10\uffff\1\45\1\46\1\47\1\50\1\67\1\51\1\52\1\62"
4411         u"\1\143\1\57\1\72\1\53\1\63\1\73\1\60\1\54\1\70\1\150\1\147\1\55"
4412         u"\1\71\1\56\1\76\1\103\1\64\1\65\1\107\1\66\1\112\1\uffff\1\110"
4413         u"\1\uffff\1\113\1\111\1\77\1\105\1\100\1\102\1\104\1\101\5\uffff"
4414         u"\1\136\1\137\1\140\1\141\2\uffff\1\144\1\145\1\151\23\uffff\1\123"
4415         u"\5\uffff\1\127\3\uffff\1\33\7\uffff\1\74\1\114\1\75\1\115\5\uffff"
4416         u"\1\142\24\uffff\1\15\1\uffff\1\130\5\uffff\1\34\15\uffff\1\30\1"
4417         u"\124\7\uffff\1\7\3\uffff\1\12\3\uffff\1\121\1\13\1\16\16\uffff"
4418         u"\1\117\1\uffff\1\131\10\uffff\1\14\5\uffff\1\31\1\17\3\uffff\1"
4419         u"\26\1\uffff\1\36\7\uffff\1\120\1\126\1\133\1\uffff\1\5\1\25\1\6"
4420         u"\1\125\1\21\1\61\1\uffff\1\134\1\11\2\uffff\1\20\10\uffff\1\42"
4421         u"\1\uffff\1\2\3\uffff\1\122\7\uffff\1\116\1\10\1\32\1\132\1\22\1"
4422         u"\35\1\uffff\1\40\3\uffff\1\37\23\uffff\1\43\6\uffff\1\44\12\uffff"
4423         u"\1\41"
4424         )
4425
4426     DFA35_special = DFA.unpack(
4427         u"\u018b\uffff"
4428         )
4429
4430
4431     DFA35_transition = [
4432         DFA.unpack(u"\6\72\2\67\1\72\2\67\22\72\1\67\1\47\1\64\1\71\1\62"
4433         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"
4434         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"
4435         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"
4436         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"
4437         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"
4438         u"\1\53\1\22\1\46\uff80\72"),
4439         DFA.unpack(u""),
4440         DFA.unpack(u"\1\74"),
4441         DFA.unpack(u""),
4442         DFA.unpack(u"\1\77"),
4443         DFA.unpack(u"\1\102\1\uffff\1\101\11\uffff\1\103"),
4444         DFA.unpack(u"\1\107\1\106\12\uffff\1\104\2\uffff\1\105"),
4445         DFA.unpack(u"\1\110"),
4446         DFA.unpack(u"\1\111"),
4447         DFA.unpack(u"\1\112"),
4448         DFA.unpack(u"\1\113"),
4449         DFA.unpack(u"\1\115\6\uffff\1\116\6\uffff\1\114"),
4450         DFA.unpack(u"\1\117\7\uffff\1\120"),
4451         DFA.unpack(u"\1\121"),
4452         DFA.unpack(u"\1\123\2\uffff\1\122"),
4453         DFA.unpack(u"\1\125\11\uffff\1\124"),
4454         DFA.unpack(u"\1\126"),
4455         DFA.unpack(u""),
4456         DFA.unpack(u""),
4457         DFA.unpack(u""),
4458         DFA.unpack(u"\1\132"),
4459         DFA.unpack(u"\1\134\4\uffff\1\133"),
4460         DFA.unpack(u"\1\135"),
4461         DFA.unpack(u"\1\136"),
4462         DFA.unpack(u"\1\137"),
4463         DFA.unpack(u"\1\140"),
4464         DFA.unpack(u"\1\141"),
4465         DFA.unpack(u""),
4466         DFA.unpack(u""),
4467         DFA.unpack(u""),
4468         DFA.unpack(u""),
4469         DFA.unpack(u"\1\146"),
4470         DFA.unpack(u"\1\150\1\uffff\12\152"),
4471         DFA.unpack(u"\1\153\21\uffff\1\154"),
4472         DFA.unpack(u"\1\160\17\uffff\1\157\1\156"),
4473         DFA.unpack(u"\1\164\4\uffff\1\163\15\uffff\1\162"),
4474         DFA.unpack(u"\1\166"),
4475         DFA.unpack(u"\1\171\26\uffff\1\170"),
4476         DFA.unpack(u""),
4477         DFA.unpack(u"\1\174"),
4478         DFA.unpack(u"\1\177\1\176"),
4479         DFA.unpack(u"\1\u0082\1\u0081"),
4480         DFA.unpack(u"\1\u0084"),
4481         DFA.unpack(u"\1\u0086\76\uffff\1\u0087"),
4482         DFA.unpack(u""),
4483         DFA.unpack(u"\1\u008a\1\uffff\1\u008b"),
4484         DFA.unpack(u"\1\u008c"),
4485         DFA.unpack(u"\1\u008d"),
4486         DFA.unpack(u"\1\u008e"),
4487         DFA.unpack(u"\1\u0090\4\uffff\1\u008f"),
4488         DFA.unpack(u""),
4489         DFA.unpack(u"\47\u008f\1\uffff\uffd7\u008f"),
4490         DFA.unpack(u"\uffff\u0090"),
4491         DFA.unpack(u"\1\152\1\uffff\10\u0093\2\152\12\uffff\3\152\21\uffff"
4492         u"\1\u0091\13\uffff\3\152\21\uffff\1\u0091"),
4493         DFA.unpack(u"\1\152\1\uffff\12\u0094\12\uffff\3\152\35\uffff\3\152"),
4494         DFA.unpack(u""),
4495         DFA.unpack(u""),
4496         DFA.unpack(u"\uffff\u0097"),
4497         DFA.unpack(u""),
4498         DFA.unpack(u""),
4499         DFA.unpack(u"\1\u0098"),
4500         DFA.unpack(u""),
4501         DFA.unpack(u""),
4502         DFA.unpack(u""),
4503         DFA.unpack(u""),
4504         DFA.unpack(u"\1\u0099"),
4505         DFA.unpack(u"\1\u009a"),
4506         DFA.unpack(u"\1\u009b"),
4507         DFA.unpack(u"\1\u009d\20\uffff\1\u009c"),
4508         DFA.unpack(u"\1\u009e"),
4509         DFA.unpack(u"\1\u009f\22\uffff\1\u00a0"),
4510         DFA.unpack(u"\1\u00a1"),
4511         DFA.unpack(u"\1\u00a2"),
4512         DFA.unpack(u"\1\u00a3\14\uffff\1\u00a4"),
4513         DFA.unpack(u"\1\u00a5"),
4514         DFA.unpack(u"\1\u00a6\2\uffff\1\u00a7"),
4515         DFA.unpack(u"\1\u00a8"),
4516         DFA.unpack(u"\1\u00a9"),
4517         DFA.unpack(u"\1\u00aa"),
4518         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4519         u"\32\75"),
4520         DFA.unpack(u"\1\u00ac"),
4521         DFA.unpack(u"\1\u00ad"),
4522         DFA.unpack(u"\1\u00ae"),
4523         DFA.unpack(u"\1\u00af"),
4524         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4525         u"\24\75\1\u00b0\5\75"),
4526         DFA.unpack(u"\1\u00b2"),
4527         DFA.unpack(u"\1\u00b4\11\uffff\1\u00b3"),
4528         DFA.unpack(u""),
4529         DFA.unpack(u""),
4530         DFA.unpack(u""),
4531         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4532         u"\32\75"),
4533         DFA.unpack(u"\1\u00b6"),
4534         DFA.unpack(u"\1\u00b7"),
4535         DFA.unpack(u"\1\u00b8"),
4536         DFA.unpack(u"\1\u00b9"),
4537         DFA.unpack(u"\1\u00ba"),
4538         DFA.unpack(u"\1\u00bb"),
4539         DFA.unpack(u"\1\u00bc"),
4540         DFA.unpack(u""),
4541         DFA.unpack(u""),
4542         DFA.unpack(u""),
4543         DFA.unpack(u""),
4544         DFA.unpack(u""),
4545         DFA.unpack(u""),
4546         DFA.unpack(u""),
4547         DFA.unpack(u""),
4548         DFA.unpack(u""),
4549         DFA.unpack(u""),
4550         DFA.unpack(u""),
4551         DFA.unpack(u""),
4552         DFA.unpack(u""),
4553         DFA.unpack(u""),
4554         DFA.unpack(u""),
4555         DFA.unpack(u""),
4556         DFA.unpack(u""),
4557         DFA.unpack(u""),
4558         DFA.unpack(u""),
4559         DFA.unpack(u""),
4560         DFA.unpack(u""),
4561         DFA.unpack(u""),
4562         DFA.unpack(u""),
4563         DFA.unpack(u""),
4564         DFA.unpack(u""),
4565         DFA.unpack(u""),
4566         DFA.unpack(u""),
4567         DFA.unpack(u""),
4568         DFA.unpack(u""),
4569         DFA.unpack(u"\1\u00bd"),
4570         DFA.unpack(u""),
4571         DFA.unpack(u"\1\u00bf"),
4572         DFA.unpack(u""),
4573         DFA.unpack(u""),
4574         DFA.unpack(u""),
4575         DFA.unpack(u""),
4576         DFA.unpack(u""),
4577         DFA.unpack(u""),
4578         DFA.unpack(u""),
4579         DFA.unpack(u""),
4580         DFA.unpack(u"\1\u00c1"),
4581         DFA.unpack(u"\1\u00c2"),
4582         DFA.unpack(u"\1\u00c3"),
4583         DFA.unpack(u"\1\u00c4"),
4584         DFA.unpack(u"\1\u00c5"),
4585         DFA.unpack(u""),
4586         DFA.unpack(u""),
4587         DFA.unpack(u""),
4588         DFA.unpack(u""),
4589         DFA.unpack(u"\1\152\1\uffff\10\u0093\2\152\12\uffff\3\152\35\uffff"
4590         u"\3\152"),
4591         DFA.unpack(u"\1\152\1\uffff\12\u0094\12\uffff\3\152\35\uffff\3\152"),
4592         DFA.unpack(u""),
4593         DFA.unpack(u""),
4594         DFA.unpack(u""),
4595         DFA.unpack(u"\1\u00c7"),
4596         DFA.unpack(u"\1\u00c8"),
4597         DFA.unpack(u"\1\u00c9"),
4598         DFA.unpack(u"\1\u00ca"),
4599         DFA.unpack(u"\1\u00cb"),
4600         DFA.unpack(u"\1\u00cc"),
4601         DFA.unpack(u"\1\u00cd"),
4602         DFA.unpack(u"\1\u00ce"),
4603         DFA.unpack(u"\1\u00cf"),
4604         DFA.unpack(u"\1\u00d0"),
4605         DFA.unpack(u"\1\u00d1"),
4606         DFA.unpack(u"\1\u00d2"),
4607         DFA.unpack(u"\1\u00d3"),
4608         DFA.unpack(u"\1\u00d4"),
4609         DFA.unpack(u"\1\u00d5"),
4610         DFA.unpack(u"\1\u00d6"),
4611         DFA.unpack(u"\1\u00d8\1\u00d7"),
4612         DFA.unpack(u"\1\u00d9"),
4613         DFA.unpack(u"\1\u00da"),
4614         DFA.unpack(u""),
4615         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4616         u"\32\75"),
4617         DFA.unpack(u"\1\u00dc"),
4618         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4619         u"\32\75"),
4620         DFA.unpack(u"\1\u00de"),
4621         DFA.unpack(u"\1\u00df"),
4622         DFA.unpack(u""),
4623         DFA.unpack(u"\1\u00e0"),
4624         DFA.unpack(u"\1\u00e1"),
4625         DFA.unpack(u"\1\u00e2"),
4626         DFA.unpack(u""),
4627         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4628         u"\32\75"),
4629         DFA.unpack(u"\1\u00e4"),
4630         DFA.unpack(u"\1\u00e5"),
4631         DFA.unpack(u"\1\u00e6"),
4632         DFA.unpack(u"\1\u00e7"),
4633         DFA.unpack(u"\1\u00e8"),
4634         DFA.unpack(u"\1\u00ea\35\uffff\1\u00e9"),
4635         DFA.unpack(u""),
4636         DFA.unpack(u""),
4637         DFA.unpack(u""),
4638         DFA.unpack(u""),
4639         DFA.unpack(u"\1\u00eb"),
4640         DFA.unpack(u"\1\u00ec"),
4641         DFA.unpack(u"\1\u00ed"),
4642         DFA.unpack(u"\1\u00ee"),
4643         DFA.unpack(u"\1\u00ef"),
4644         DFA.unpack(u""),
4645         DFA.unpack(u"\1\u00f0"),
4646         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4647         u"\32\75"),
4648         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4649         u"\32\75"),
4650         DFA.unpack(u"\1\u00f3"),
4651         DFA.unpack(u"\1\u00f4"),
4652         DFA.unpack(u"\1\u00f5"),
4653         DFA.unpack(u"\1\u00f6"),
4654         DFA.unpack(u"\1\u00f7"),
4655         DFA.unpack(u"\1\u00f8"),
4656         DFA.unpack(u"\1\u00f9"),
4657         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4658         u"\32\75"),
4659         DFA.unpack(u"\1\u00fb"),
4660         DFA.unpack(u"\1\u00fc"),
4661         DFA.unpack(u"\1\u00fd"),
4662         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4663         u"\32\75"),
4664         DFA.unpack(u"\1\u00ff"),
4665         DFA.unpack(u"\1\u0100"),
4666         DFA.unpack(u"\1\u0101"),
4667         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4668         u"\32\75"),
4669         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4670         u"\32\75"),
4671         DFA.unpack(u""),
4672         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4673         u"\32\75"),
4674         DFA.unpack(u""),
4675         DFA.unpack(u"\1\u0105"),
4676         DFA.unpack(u"\1\u0106"),
4677         DFA.unpack(u"\1\u0107"),
4678         DFA.unpack(u"\1\u0108"),
4679         DFA.unpack(u"\1\u0109"),
4680         DFA.unpack(u""),
4681         DFA.unpack(u"\1\u010a"),
4682         DFA.unpack(u"\1\u010b"),
4683         DFA.unpack(u"\1\u010c"),
4684         DFA.unpack(u"\1\u010d"),
4685         DFA.unpack(u"\1\u010e"),
4686         DFA.unpack(u"\1\u010f\17\uffff\1\u0110"),
4687         DFA.unpack(u"\1\u0111"),
4688         DFA.unpack(u"\1\u0112"),
4689         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4690         u"\32\75"),
4691         DFA.unpack(u"\1\u0114"),
4692         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4693         u"\32\75"),
4694         DFA.unpack(u"\1\u0116"),
4695         DFA.unpack(u"\1\u0117"),
4696         DFA.unpack(u""),
4697         DFA.unpack(u""),
4698         DFA.unpack(u"\1\u0118"),
4699         DFA.unpack(u"\1\u0119"),
4700         DFA.unpack(u"\1\u011a"),
4701         DFA.unpack(u"\1\u011b"),
4702         DFA.unpack(u"\1\u011c"),
4703         DFA.unpack(u"\1\u011d"),
4704         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4705         u"\32\75"),
4706         DFA.unpack(u""),
4707         DFA.unpack(u"\1\u011f"),
4708         DFA.unpack(u"\1\u0120"),
4709         DFA.unpack(u"\1\u0121"),
4710         DFA.unpack(u""),
4711         DFA.unpack(u"\1\u0122"),
4712         DFA.unpack(u"\1\u0123"),
4713         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4714         u"\32\75"),
4715         DFA.unpack(u""),
4716         DFA.unpack(u""),
4717         DFA.unpack(u""),
4718         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4719         u"\32\75"),
4720         DFA.unpack(u"\1\u0126"),
4721         DFA.unpack(u"\1\u0127"),
4722         DFA.unpack(u"\1\u0128"),
4723         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4724         u"\32\75"),
4725         DFA.unpack(u"\1\u012a"),
4726         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4727         u"\32\75"),
4728         DFA.unpack(u"\1\u012c"),
4729         DFA.unpack(u"\1\u012d"),
4730         DFA.unpack(u"\1\u012e"),
4731         DFA.unpack(u"\1\u012f"),
4732         DFA.unpack(u"\1\u0130"),
4733         DFA.unpack(u"\1\u0131"),
4734         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\u0132\1"
4735         u"\uffff\32\75"),
4736         DFA.unpack(u""),
4737         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4738         u"\32\75"),
4739         DFA.unpack(u""),
4740         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4741         u"\32\75"),
4742         DFA.unpack(u"\1\u0136"),
4743         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4744         u"\32\75"),
4745         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4746         u"\32\75"),
4747         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4748         u"\32\75"),
4749         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4750         u"\32\75"),
4751         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4752         u"\32\75"),
4753         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4754         u"\32\75"),
4755         DFA.unpack(u""),
4756         DFA.unpack(u"\1\u013d"),
4757         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4758         u"\32\75"),
4759         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4760         u"\32\75"),
4761         DFA.unpack(u"\1\u0140"),
4762         DFA.unpack(u"\1\u0141"),
4763         DFA.unpack(u""),
4764         DFA.unpack(u""),
4765         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4766         u"\32\75"),
4767         DFA.unpack(u"\1\u0143"),
4768         DFA.unpack(u"\1\u0144"),
4769         DFA.unpack(u""),
4770         DFA.unpack(u"\1\u0145"),
4771         DFA.unpack(u""),
4772         DFA.unpack(u"\1\u0146"),
4773         DFA.unpack(u"\1\u0147"),
4774         DFA.unpack(u"\1\u0148"),
4775         DFA.unpack(u"\1\u0149"),
4776         DFA.unpack(u"\1\u014a"),
4777         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4778         u"\32\75"),
4779         DFA.unpack(u"\1\u014c"),
4780         DFA.unpack(u""),
4781         DFA.unpack(u""),
4782         DFA.unpack(u""),
4783         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4784         u"\32\75"),
4785         DFA.unpack(u""),
4786         DFA.unpack(u""),
4787         DFA.unpack(u""),
4788         DFA.unpack(u""),
4789         DFA.unpack(u""),
4790         DFA.unpack(u""),
4791         DFA.unpack(u"\1\u014e"),
4792         DFA.unpack(u""),
4793         DFA.unpack(u""),
4794         DFA.unpack(u"\1\u014f"),
4795         DFA.unpack(u"\1\u0150"),
4796         DFA.unpack(u""),
4797         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4798         u"\32\75"),
4799         DFA.unpack(u"\1\u0152"),
4800         DFA.unpack(u"\1\u0153"),
4801         DFA.unpack(u"\1\u0154"),
4802         DFA.unpack(u"\1\u0155"),
4803         DFA.unpack(u"\1\u0156"),
4804         DFA.unpack(u"\1\u0157"),
4805         DFA.unpack(u"\1\u0158"),
4806         DFA.unpack(u""),
4807         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4808         u"\32\75"),
4809         DFA.unpack(u""),
4810         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4811         u"\32\75"),
4812         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4813         u"\32\75"),
4814         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4815         u"\32\75"),
4816         DFA.unpack(u""),
4817         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4818         u"\32\75"),
4819         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4820         u"\32\75"),
4821         DFA.unpack(u"\1\u015f"),
4822         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4823         u"\32\75"),
4824         DFA.unpack(u"\1\u0161"),
4825         DFA.unpack(u"\1\u0162"),
4826         DFA.unpack(u"\1\u0163"),
4827         DFA.unpack(u""),
4828         DFA.unpack(u""),
4829         DFA.unpack(u""),
4830         DFA.unpack(u""),
4831         DFA.unpack(u""),
4832         DFA.unpack(u""),
4833         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4834         u"\32\75"),
4835         DFA.unpack(u""),
4836         DFA.unpack(u"\1\u0165"),
4837         DFA.unpack(u"\1\u0166"),
4838         DFA.unpack(u"\1\u0167"),
4839         DFA.unpack(u""),
4840         DFA.unpack(u"\1\u0168"),
4841         DFA.unpack(u"\1\u0169"),
4842         DFA.unpack(u"\1\u016a"),
4843         DFA.unpack(u"\1\u016b"),
4844         DFA.unpack(u"\1\u016c"),
4845         DFA.unpack(u"\1\u016d"),
4846         DFA.unpack(u"\1\u016e"),
4847         DFA.unpack(u"\1\u016f"),
4848         DFA.unpack(u"\1\u0170"),
4849         DFA.unpack(u"\1\u0171"),
4850         DFA.unpack(u"\1\u0172"),
4851         DFA.unpack(u"\1\u0173"),
4852         DFA.unpack(u"\1\u0174"),
4853         DFA.unpack(u"\1\u0175"),
4854         DFA.unpack(u"\1\u0176"),
4855         DFA.unpack(u"\1\u0177"),
4856         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4857         u"\32\75"),
4858         DFA.unpack(u"\1\u0179"),
4859         DFA.unpack(u"\1\u017a"),
4860         DFA.unpack(u""),
4861         DFA.unpack(u"\1\u017b"),
4862         DFA.unpack(u"\1\u017c"),
4863         DFA.unpack(u"\1\u017d"),
4864         DFA.unpack(u"\1\u017e"),
4865         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4866         u"\32\75"),
4867         DFA.unpack(u"\1\u0180"),
4868         DFA.unpack(u""),
4869         DFA.unpack(u"\1\u0181"),
4870         DFA.unpack(u"\1\u0182"),
4871         DFA.unpack(u"\1\u0183"),
4872         DFA.unpack(u"\1\u0184"),
4873         DFA.unpack(u"\1\u0185"),
4874         DFA.unpack(u"\1\u0186"),
4875         DFA.unpack(u"\1\u0187"),
4876         DFA.unpack(u"\1\u0188"),
4877         DFA.unpack(u"\1\u0189"),
4878         DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff"
4879         u"\32\75"),
4880         DFA.unpack(u"")
4881     ]
4882
4883     # class definition for DFA #35
4884
4885     DFA35 = DFA
4886
4887