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