BaseTools/Source/Python/Eot/CParser3/CLexer.py

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