1
2
3
4 #include <sngcm/cmlexer/CmajorLexer.hpp>
5 #include <sngcm/cmlexer/CmajorKeywords.hpp>
6 #include <soulng/lexer/Token.hpp>
7 #include <sngcm/cmlexer/CmajorTokens.hpp>
8 #include <sngcm/cmlexer/CmajorClassMap.hpp>
9
10 using namespace soulng::lexer;
11 using namespace CmajorTokens;
12
13 CmajorLexer::CmajorLexer(const std::u32string& content_, const std::string& fileName_, int fileIndex_) : soulng::lexer::Lexer(content_, fileName_, fileIndex_),
14 floatingLit(), floatingLitFloat(), intLit(), intLitUnsigned(), chrLit(), chrLitPrefix(), strLit(), strLitPrefix(), leftAngleCount(), parsingOperatorFunctionGroupId()
15 {
16 SetKeywordMap(CmajorKeywords::GetKeywordMap());
17 }
18
19 CmajorLexer::CmajorLexer(const char32_t* start_, const char32_t* end_, const std::string& fileName_, int fileIndex_) : soulng::lexer::Lexer(start_, end_, fileName_, fileIndex_),
20 floatingLit(), floatingLitFloat(), intLit(), intLitUnsigned(), chrLit(), chrLitPrefix(), strLit(), strLitPrefix(), leftAngleCount(), parsingOperatorFunctionGroupId()
21 {
22 SetKeywordMap(CmajorKeywords::GetKeywordMap());
23 }
24
25 int CmajorLexer::NextState(int state, char32_t c)
26 {
27 int i = CmajorClassMap::GetClass(c);
28 switch (state)
29 {
30 case 0:
31 {
32 switch (i)
33 {
34 case 0:
35 case 1:
36 case 6:
37 case 7:
38 {
39 return 1;
40 }
41 case 2:
42 {
43 return 2;
44 }
45 case 3:
46 {
47 return 3;
48 }
49 case 4:
50 case 9:
51 case 10:
52 case 12:
53 case 18:
54 case 19:
55 case 20:
56 case 21:
57 case 22:
58 case 23:
59 case 30:
60 case 31:
61 case 32:
62 case 33:
63 case 34:
64 case 35:
65 case 36:
66 {
67 return 4;
68 }
69 case 11:
70 {
71 return 5;
72 }
73 case 13:
74 {
75 return 6;
76 }
77 case 14:
78 {
79 return 7;
80 }
81 case 15:
82 {
83 return 8;
84 }
85 case 16:
86 {
87 return 9;
88 }
89 case 17:
90 {
91 return 10;
92 }
93 case 24:
94 case 26:
95 {
96 return 11;
97 }
98 case 25:
99 {
100 return 12;
101 }
102 case 27:
103 {
104 return 13;
105 }
106 case 29:
107 {
108 return 14;
109 }
110 case 37:
111 {
112 return 15;
113 }
114 case 38:
115 {
116 return 16;
117 }
118 case 39:
119 {
120 return 17;
121 }
122 case 40:
123 {
124 return 18;
125 }
126 case 41:
127 {
128 return 19;
129 }
130 case 42:
131 {
132 return 20;
133 }
134 case 43:
135 {
136 return 21;
137 }
138 case 44:
139 {
140 return 22;
141 }
142 case 45:
143 {
144 return 23;
145 }
146 case 46:
147 {
148 return 24;
149 }
150 case 47:
151 {
152 return 25;
153 }
154 case 48:
155 {
156 return 26;
157 }
158 case 49:
159 {
160 return 27;
161 }
162 case 50:
163 {
164 return 28;
165 }
166 case 51:
167 {
168 return 29;
169 }
170 case 52:
171 {
172 return 30;
173 }
174 case 53:
175 {
176 return 31;
177 }
178 case 54:
179 {
180 return 32;
181 }
182 case 55:
183 {
184 return 33;
185 }
186 default:
187 {
188 return -1;
189 }
190 }
191 }
192 case 33:
193 {
194 Lexeme prevMatch = token.match;
195 token.match = lexeme;
196 int tokenId = GetTokenId(42);
197 if (tokenId == CONTINUE_TOKEN)
198 {
199 token.id = tokenId;
200 return -1;
201 }
202 else if (tokenId != INVALID_TOKEN)
203 {
204 token.id = tokenId;
205 }
206 else
207 {
208 token.match = prevMatch;
209 }
210 return -1;
211 }
212 case 32:
213 {
214 Lexeme prevMatch = token.match;
215 token.match = lexeme;
216 int tokenId = GetTokenId(41);
217 if (tokenId == CONTINUE_TOKEN)
218 {
219 token.id = tokenId;
220 return -1;
221 }
222 else if (tokenId != INVALID_TOKEN)
223 {
224 token.id = tokenId;
225 }
226 else
227 {
228 token.match = prevMatch;
229 }
230 return -1;
231 }
232 case 31:
233 {
234 Lexeme prevMatch = token.match;
235 token.match = lexeme;
236 int tokenId = GetTokenId(40);
237 if (tokenId == CONTINUE_TOKEN)
238 {
239 token.id = tokenId;
240 return -1;
241 }
242 else if (tokenId != INVALID_TOKEN)
243 {
244 token.id = tokenId;
245 }
246 else
247 {
248 token.match = prevMatch;
249 }
250 return -1;
251 }
252 case 30:
253 {
254 Lexeme prevMatch = token.match;
255 token.match = lexeme;
256 int tokenId = GetTokenId(38);
257 if (tokenId == CONTINUE_TOKEN)
258 {
259 token.id = tokenId;
260 return -1;
261 }
262 else if (tokenId != INVALID_TOKEN)
263 {
264 token.id = tokenId;
265 }
266 else
267 {
268 token.match = prevMatch;
269 }
270 return -1;
271 }
272 case 29:
273 {
274 Lexeme prevMatch = token.match;
275 token.match = lexeme;
276 int tokenId = GetTokenId(37);
277 if (tokenId == CONTINUE_TOKEN)
278 {
279 token.id = tokenId;
280 return -1;
281 }
282 else if (tokenId != INVALID_TOKEN)
283 {
284 token.id = tokenId;
285 }
286 else
287 {
288 token.match = prevMatch;
289 }
290 return -1;
291 }
292 case 28:
293 {
294 Lexeme prevMatch = token.match;
295 token.match = lexeme;
296 int tokenId = GetTokenId(36);
297 if (tokenId == CONTINUE_TOKEN)
298 {
299 token.id = tokenId;
300 return -1;
301 }
302 else if (tokenId != INVALID_TOKEN)
303 {
304 token.id = tokenId;
305 }
306 else
307 {
308 token.match = prevMatch;
309 }
310 return -1;
311 }
312 case 27:
313 {
314 Lexeme prevMatch = token.match;
315 token.match = lexeme;
316 int tokenId = GetTokenId(35);
317 if (tokenId == CONTINUE_TOKEN)
318 {
319 token.id = tokenId;
320 return -1;
321 }
322 else if (tokenId != INVALID_TOKEN)
323 {
324 token.id = tokenId;
325 }
326 else
327 {
328 token.match = prevMatch;
329 }
330 return -1;
331 }
332 case 26:
333 {
334 Lexeme prevMatch = token.match;
335 token.match = lexeme;
336 int tokenId = GetTokenId(34);
337 if (tokenId == CONTINUE_TOKEN)
338 {
339 token.id = tokenId;
340 return -1;
341 }
342 else if (tokenId != INVALID_TOKEN)
343 {
344 token.id = tokenId;
345 }
346 else
347 {
348 token.match = prevMatch;
349 }
350 return -1;
351 }
352 case 25:
353 {
354 Lexeme prevMatch = token.match;
355 token.match = lexeme;
356 int tokenId = GetTokenId(33);
357 if (tokenId == CONTINUE_TOKEN)
358 {
359 token.id = tokenId;
360 return -1;
361 }
362 else if (tokenId != INVALID_TOKEN)
363 {
364 token.id = tokenId;
365 }
366 else
367 {
368 token.match = prevMatch;
369 }
370 return -1;
371 }
372 case 24:
373 {
374 Lexeme prevMatch = token.match;
375 token.match = lexeme;
376 int tokenId = GetTokenId(32);
377 if (tokenId == CONTINUE_TOKEN)
378 {
379 token.id = tokenId;
380 return -1;
381 }
382 else if (tokenId != INVALID_TOKEN)
383 {
384 token.id = tokenId;
385 }
386 else
387 {
388 token.match = prevMatch;
389 }
390 return -1;
391 }
392 case 23:
393 {
394 Lexeme prevMatch = token.match;
395 token.match = lexeme;
396 int tokenId = GetTokenId(29);
397 if (tokenId == CONTINUE_TOKEN)
398 {
399 token.id = tokenId;
400 return -1;
401 }
402 else if (tokenId != INVALID_TOKEN)
403 {
404 token.id = tokenId;
405 }
406 else
407 {
408 token.match = prevMatch;
409 }
410 return -1;
411 }
412 case 22:
413 {
414 Lexeme prevMatch = token.match;
415 token.match = lexeme;
416 int tokenId = GetTokenId(25);
417 if (tokenId == CONTINUE_TOKEN)
418 {
419 token.id = tokenId;
420 return -1;
421 }
422 else if (tokenId != INVALID_TOKEN)
423 {
424 token.id = tokenId;
425 }
426 else
427 {
428 token.match = prevMatch;
429 }
430 return -1;
431 }
432 case 21:
433 {
434 Lexeme prevMatch = token.match;
435 token.match = lexeme;
436 int tokenId = GetTokenId(28);
437 if (tokenId == CONTINUE_TOKEN)
438 {
439 token.id = tokenId;
440 return -1;
441 }
442 else if (tokenId != INVALID_TOKEN)
443 {
444 token.id = tokenId;
445 }
446 else
447 {
448 token.match = prevMatch;
449 }
450 switch (i)
451 {
452 case 38:
453 {
454 return 34;
455 }
456 default:
457 {
458 return -1;
459 }
460 }
461 }
462 case 34:
463 {
464 Lexeme prevMatch = token.match;
465 token.match = lexeme;
466 int tokenId = GetTokenId(14);
467 if (tokenId == CONTINUE_TOKEN)
468 {
469 token.id = tokenId;
470 return -1;
471 }
472 else if (tokenId != INVALID_TOKEN)
473 {
474 token.id = tokenId;
475 }
476 else
477 {
478 token.match = prevMatch;
479 }
480 return -1;
481 }
482 case 20:
483 {
484 Lexeme prevMatch = token.match;
485 token.match = lexeme;
486 int tokenId = GetTokenId(11);
487 if (tokenId == CONTINUE_TOKEN)
488 {
489 token.id = tokenId;
490 return -1;
491 }
492 else if (tokenId != INVALID_TOKEN)
493 {
494 token.id = tokenId;
495 }
496 else
497 {
498 token.match = prevMatch;
499 }
500 return -1;
501 }
502 case 19:
503 {
504 Lexeme prevMatch = token.match;
505 token.match = lexeme;
506 int tokenId = GetTokenId(12);
507 if (tokenId == CONTINUE_TOKEN)
508 {
509 token.id = tokenId;
510 return -1;
511 }
512 else if (tokenId != INVALID_TOKEN)
513 {
514 token.id = tokenId;
515 }
516 else
517 {
518 token.match = prevMatch;
519 }
520 switch (i)
521 {
522 case 41:
523 {
524 return 35;
525 }
526 default:
527 {
528 return -1;
529 }
530 }
531 }
532 case 35:
533 {
534 Lexeme prevMatch = token.match;
535 token.match = lexeme;
536 int tokenId = GetTokenId(9);
537 if (tokenId == CONTINUE_TOKEN)
538 {
539 token.id = tokenId;
540 return -1;
541 }
542 else if (tokenId != INVALID_TOKEN)
543 {
544 token.id = tokenId;
545 }
546 else
547 {
548 token.match = prevMatch;
549 }
550 return -1;
551 }
552 case 18:
553 {
554 Lexeme prevMatch = token.match;
555 token.match = lexeme;
556 int tokenId = GetTokenId(10);
557 if (tokenId == CONTINUE_TOKEN)
558 {
559 token.id = tokenId;
560 return -1;
561 }
562 else if (tokenId != INVALID_TOKEN)
563 {
564 token.id = tokenId;
565 }
566 else
567 {
568 token.match = prevMatch;
569 }
570 switch (i)
571 {
572 case 40:
573 {
574 return 36;
575 }
576 default:
577 {
578 return -1;
579 }
580 }
581 }
582 case 36:
583 {
584 Lexeme prevMatch = token.match;
585 token.match = lexeme;
586 int tokenId = GetTokenId(8);
587 if (tokenId == CONTINUE_TOKEN)
588 {
589 token.id = tokenId;
590 return -1;
591 }
592 else if (tokenId != INVALID_TOKEN)
593 {
594 token.id = tokenId;
595 }
596 else
597 {
598 token.match = prevMatch;
599 }
600 return -1;
601 }
602 case 17:
603 {
604 Lexeme prevMatch = token.match;
605 token.match = lexeme;
606 int tokenId = GetTokenId(18);
607 if (tokenId == CONTINUE_TOKEN)
608 {
609 token.id = tokenId;
610 return -1;
611 }
612 else if (tokenId != INVALID_TOKEN)
613 {
614 token.id = tokenId;
615 }
616 else
617 {
618 token.match = prevMatch;
619 }
620 switch (i)
621 {
622 case 38:
623 {
624 return 37;
625 }
626 case 39:
627 {
628 return 38;
629 }
630 default:
631 {
632 return -1;
633 }
634 }
635 }
636 case 38:
637 {
638 Lexeme prevMatch = token.match;
639 token.match = lexeme;
640 int tokenId = GetTokenId(20);
641 if (tokenId == CONTINUE_TOKEN)
642 {
643 token.id = tokenId;
644 return -1;
645 }
646 else if (tokenId != INVALID_TOKEN)
647 {
648 token.id = tokenId;
649 }
650 else
651 {
652 token.match = prevMatch;
653 }
654 return -1;
655 }
656 case 37:
657 {
658 Lexeme prevMatch = token.match;
659 token.match = lexeme;
660 int tokenId = GetTokenId(16);
661 if (tokenId == CONTINUE_TOKEN)
662 {
663 token.id = tokenId;
664 return -1;
665 }
666 else if (tokenId != INVALID_TOKEN)
667 {
668 token.id = tokenId;
669 }
670 else
671 {
672 token.match = prevMatch;
673 }
674 return -1;
675 }
676 case 16:
677 {
678 Lexeme prevMatch = token.match;
679 token.match = lexeme;
680 int tokenId = GetTokenId(39);
681 if (tokenId == CONTINUE_TOKEN)
682 {
683 token.id = tokenId;
684 return -1;
685 }
686 else if (tokenId != INVALID_TOKEN)
687 {
688 token.id = tokenId;
689 }
690 else
691 {
692 token.match = prevMatch;
693 }
694 switch (i)
695 {
696 case 38:
697 {
698 return 39;
699 }
700 case 39:
701 {
702 return 40;
703 }
704 default:
705 {
706 return -1;
707 }
708 }
709 }
710 case 40:
711 {
712 Lexeme prevMatch = token.match;
713 token.match = lexeme;
714 int tokenId = GetTokenId(7);
715 if (tokenId == CONTINUE_TOKEN)
716 {
717 token.id = tokenId;
718 return -1;
719 }
720 else if (tokenId != INVALID_TOKEN)
721 {
722 token.id = tokenId;
723 }
724 else
725 {
726 token.match = prevMatch;
727 }
728 return -1;
729 }
730 case 39:
731 {
732 Lexeme prevMatch = token.match;
733 token.match = lexeme;
734 int tokenId = GetTokenId(13);
735 if (tokenId == CONTINUE_TOKEN)
736 {
737 token.id = tokenId;
738 return -1;
739 }
740 else if (tokenId != INVALID_TOKEN)
741 {
742 token.id = tokenId;
743 }
744 else
745 {
746 token.match = prevMatch;
747 }
748 return -1;
749 }
750 case 15:
751 {
752 Lexeme prevMatch = token.match;
753 token.match = lexeme;
754 int tokenId = GetTokenId(17);
755 if (tokenId == CONTINUE_TOKEN)
756 {
757 token.id = tokenId;
758 return -1;
759 }
760 else if (tokenId != INVALID_TOKEN)
761 {
762 token.id = tokenId;
763 }
764 else
765 {
766 token.match = prevMatch;
767 }
768 switch (i)
769 {
770 case 37:
771 {
772 return 41;
773 }
774 case 38:
775 {
776 return 42;
777 }
778 default:
779 {
780 return -1;
781 }
782 }
783 }
784 case 42:
785 {
786 Lexeme prevMatch = token.match;
787 token.match = lexeme;
788 int tokenId = GetTokenId(15);
789 if (tokenId == CONTINUE_TOKEN)
790 {
791 token.id = tokenId;
792 return -1;
793 }
794 else if (tokenId != INVALID_TOKEN)
795 {
796 token.id = tokenId;
797 }
798 else
799 {
800 token.match = prevMatch;
801 }
802 switch (i)
803 {
804 case 39:
805 {
806 return 43;
807 }
808 default:
809 {
810 return -1;
811 }
812 }
813 }
814 case 43:
815 {
816 Lexeme prevMatch = token.match;
817 token.match = lexeme;
818 int tokenId = GetTokenId(6);
819 if (tokenId == CONTINUE_TOKEN)
820 {
821 token.id = tokenId;
822 return -1;
823 }
824 else if (tokenId != INVALID_TOKEN)
825 {
826 token.id = tokenId;
827 }
828 else
829 {
830 token.match = prevMatch;
831 }
832 return -1;
833 }
834 case 41:
835 {
836 Lexeme prevMatch = token.match;
837 token.match = lexeme;
838 int tokenId = GetTokenId(19);
839 if (tokenId == CONTINUE_TOKEN)
840 {
841 token.id = tokenId;
842 return -1;
843 }
844 else if (tokenId != INVALID_TOKEN)
845 {
846 token.id = tokenId;
847 }
848 else
849 {
850 token.match = prevMatch;
851 }
852 return -1;
853 }
854 case 14:
855 {
856 switch (i)
857 {
858 case 2:
859 case 3:
860 case 4:
861 case 5:
862 case 6:
863 case 7:
864 case 8:
865 case 9:
866 case 10:
867 case 11:
868 case 12:
869 case 13:
870 case 14:
871 case 15:
872 case 16:
873 case 17:
874 case 18:
875 case 19:
876 case 20:
877 case 21:
878 case 22:
879 case 23:
880 case 24:
881 case 25:
882 case 26:
883 case 27:
884 case 30:
885 case 31:
886 case 32:
887 case 33:
888 case 34:
889 case 35:
890 case 36:
891 case 37:
892 case 38:
893 case 39:
894 case 40:
895 case 41:
896 case 42:
897 case 43:
898 case 44:
899 case 45:
900 case 46:
901 case 47:
902 case 48:
903 case 49:
904 case 50:
905 case 51:
906 case 52:
907 case 53:
908 case 54:
909 case 55:
910 {
911 return 44;
912 }
913 case 28:
914 {
915 return 45;
916 }
917 case 29:
918 {
919 return 46;
920 }
921 default:
922 {
923 return -1;
924 }
925 }
926 }
927 case 46:
928 {
929 Lexeme prevMatch = token.match;
930 token.match = lexeme;
931 int tokenId = GetTokenId(4);
932 if (tokenId == CONTINUE_TOKEN)
933 {
934 token.id = tokenId;
935 return -1;
936 }
937 else if (tokenId != INVALID_TOKEN)
938 {
939 token.id = tokenId;
940 }
941 else
942 {
943 token.match = prevMatch;
944 }
945 return -1;
946 }
947 case 45:
948 {
949 switch (i)
950 {
951 case 9:
952 {
953 return 47;
954 }
955 case 10:
956 {
957 return 48;
958 }
959 case 11:
960 {
961 return 49;
962 }
963 case 12:
964 {
965 return 50;
966 }
967 case 22:
968 {
969 return 51;
970 }
971 case 23:
972 {
973 return 52;
974 }
975 case 25:
976 case 26:
977 {
978 return 53;
979 }
980 case 27:
981 case 28:
982 case 29:
983 case 30:
984 case 31:
985 case 32:
986 case 33:
987 case 34:
988 case 35:
989 case 36:
990 {
991 return 54;
992 }
993 default:
994 {
995 return -1;
996 }
997 }
998 }
999 case 54:
1000 {
1001 switch (i)
1002 {
1003 case 29:
1004 {
1005 return 46;
1006 }
1007 default:
1008 {
1009 return -1;
1010 }
1011 }
1012 }
1013 case 53:
1014 {
1015 switch (i)
1016 {
1017 case 29:
1018 {
1019 return 46;
1020 }
1021 case 25:
1022 case 26:
1023 {
1024 return 53;
1025 }
1026 default:
1027 {
1028 return -1;
1029 }
1030 }
1031 }
1032 case 52:
1033 {
1034 switch (i)
1035 {
1036 case 24:
1037 case 25:
1038 case 26:
1039 {
1040 return 55;
1041 }
1042 default:
1043 {
1044 return -1;
1045 }
1046 }
1047 }
1048 case 55:
1049 {
1050 switch (i)
1051 {
1052 case 29:
1053 {
1054 return 46;
1055 }
1056 case 24:
1057 case 25:
1058 case 26:
1059 {
1060 return 55;
1061 }
1062 default:
1063 {
1064 return -1;
1065 }
1066 }
1067 }
1068 case 51:
1069 {
1070 switch (i)
1071 {
1072 case 24:
1073 case 25:
1074 case 26:
1075 {
1076 return 55;
1077 }
1078 default:
1079 {
1080 return -1;
1081 }
1082 }
1083 }
1084 case 50:
1085 {
1086 switch (i)
1087 {
1088 case 18:
1089 case 19:
1090 case 20:
1091 case 21:
1092 case 22:
1093 case 23:
1094 case 24:
1095 case 25:
1096 case 26:
1097 case 34:
1098 case 35:
1099 case 36:
1100 {
1101 return 56;
1102 }
1103 default:
1104 {
1105 return -1;
1106 }
1107 }
1108 }
1109 case 56:
1110 {
1111 switch (i)
1112 {
1113 case 18:
1114 case 19:
1115 case 20:
1116 case 21:
1117 case 22:
1118 case 23:
1119 case 24:
1120 case 25:
1121 case 26:
1122 case 34:
1123 case 35:
1124 case 36:
1125 {
1126 return 57;
1127 }
1128 default:
1129 {
1130 return -1;
1131 }
1132 }
1133 }
1134 case 57:
1135 {
1136 switch (i)
1137 {
1138 case 18:
1139 case 19:
1140 case 20:
1141 case 21:
1142 case 22:
1143 case 23:
1144 case 24:
1145 case 25:
1146 case 26:
1147 case 34:
1148 case 35:
1149 case 36:
1150 {
1151 return 58;
1152 }
1153 default:
1154 {
1155 return -1;
1156 }
1157 }
1158 }
1159 case 58:
1160 {
1161 switch (i)
1162 {
1163 case 18:
1164 case 19:
1165 case 20:
1166 case 21:
1167 case 22:
1168 case 23:
1169 case 24:
1170 case 25:
1171 case 26:
1172 case 34:
1173 case 35:
1174 case 36:
1175 {
1176 return 59;
1177 }
1178 default:
1179 {
1180 return -1;
1181 }
1182 }
1183 }
1184 case 59:
1185 {
1186 switch (i)
1187 {
1188 case 18:
1189 case 19:
1190 case 20:
1191 case 21:
1192 case 22:
1193 case 23:
1194 case 24:
1195 case 25:
1196 case 26:
1197 case 34:
1198 case 35:
1199 case 36:
1200 {
1201 return 60;
1202 }
1203 default:
1204 {
1205 return -1;
1206 }
1207 }
1208 }
1209 case 60:
1210 {
1211 switch (i)
1212 {
1213 case 18:
1214 case 19:
1215 case 20:
1216 case 21:
1217 case 22:
1218 case 23:
1219 case 24:
1220 case 25:
1221 case 26:
1222 case 34:
1223 case 35:
1224 case 36:
1225 {
1226 return 61;
1227 }
1228 default:
1229 {
1230 return -1;
1231 }
1232 }
1233 }
1234 case 61:
1235 {
1236 switch (i)
1237 {
1238 case 18:
1239 case 19:
1240 case 20:
1241 case 21:
1242 case 22:
1243 case 23:
1244 case 24:
1245 case 25:
1246 case 26:
1247 case 34:
1248 case 35:
1249 case 36:
1250 {
1251 return 62;
1252 }
1253 default:
1254 {
1255 return -1;
1256 }
1257 }
1258 }
1259 case 62:
1260 {
1261 switch (i)
1262 {
1263 case 18:
1264 case 19:
1265 case 20:
1266 case 21:
1267 case 22:
1268 case 23:
1269 case 24:
1270 case 25:
1271 case 26:
1272 case 34:
1273 case 35:
1274 case 36:
1275 {
1276 return 63;
1277 }
1278 default:
1279 {
1280 return -1;
1281 }
1282 }
1283 }
1284 case 63:
1285 {
1286 switch (i)
1287 {
1288 case 29:
1289 {
1290 return 46;
1291 }
1292 default:
1293 {
1294 return -1;
1295 }
1296 }
1297 }
1298 case 49:
1299 {
1300 switch (i)
1301 {
1302 case 18:
1303 case 19:
1304 case 20:
1305 case 21:
1306 case 22:
1307 case 23:
1308 case 24:
1309 case 25:
1310 case 26:
1311 case 34:
1312 case 35:
1313 case 36:
1314 {
1315 return 64;
1316 }
1317 default:
1318 {
1319 return -1;
1320 }
1321 }
1322 }
1323 case 64:
1324 {
1325 switch (i)
1326 {
1327 case 18:
1328 case 19:
1329 case 20:
1330 case 21:
1331 case 22:
1332 case 23:
1333 case 24:
1334 case 25:
1335 case 26:
1336 case 34:
1337 case 35:
1338 case 36:
1339 {
1340 return 65;
1341 }
1342 default:
1343 {
1344 return -1;
1345 }
1346 }
1347 }
1348 case 65:
1349 {
1350 switch (i)
1351 {
1352 case 18:
1353 case 19:
1354 case 20:
1355 case 21:
1356 case 22:
1357 case 23:
1358 case 24:
1359 case 25:
1360 case 26:
1361 case 34:
1362 case 35:
1363 case 36:
1364 {
1365 return 66;
1366 }
1367 default:
1368 {
1369 return -1;
1370 }
1371 }
1372 }
1373 case 66:
1374 {
1375 switch (i)
1376 {
1377 case 18:
1378 case 19:
1379 case 20:
1380 case 21:
1381 case 22:
1382 case 23:
1383 case 24:
1384 case 25:
1385 case 26:
1386 case 34:
1387 case 35:
1388 case 36:
1389 {
1390 return 67;
1391 }
1392 default:
1393 {
1394 return -1;
1395 }
1396 }
1397 }
1398 case 67:
1399 {
1400 switch (i)
1401 {
1402 case 29:
1403 {
1404 return 46;
1405 }
1406 default:
1407 {
1408 return -1;
1409 }
1410 }
1411 }
1412 case 48:
1413 {
1414 switch (i)
1415 {
1416 case 18:
1417 case 19:
1418 case 20:
1419 case 21:
1420 case 22:
1421 case 23:
1422 case 24:
1423 case 25:
1424 case 26:
1425 case 34:
1426 case 35:
1427 case 36:
1428 {
1429 return 68;
1430 }
1431 default:
1432 {
1433 return -1;
1434 }
1435 }
1436 }
1437 case 68:
1438 {
1439 switch (i)
1440 {
1441 case 29:
1442 {
1443 return 46;
1444 }
1445 case 18:
1446 case 19:
1447 case 20:
1448 case 21:
1449 case 22:
1450 case 23:
1451 case 24:
1452 case 25:
1453 case 26:
1454 case 34:
1455 case 35:
1456 case 36:
1457 {
1458 return 68;
1459 }
1460 default:
1461 {
1462 return -1;
1463 }
1464 }
1465 }
1466 case 47:
1467 {
1468 switch (i)
1469 {
1470 case 18:
1471 case 19:
1472 case 20:
1473 case 21:
1474 case 22:
1475 case 23:
1476 case 24:
1477 case 25:
1478 case 26:
1479 case 34:
1480 case 35:
1481 case 36:
1482 {
1483 return 68;
1484 }
1485 default:
1486 {
1487 return -1;
1488 }
1489 }
1490 }
1491 case 44:
1492 {
1493 switch (i)
1494 {
1495 case 2:
1496 case 3:
1497 case 4:
1498 case 5:
1499 case 6:
1500 case 7:
1501 case 8:
1502 case 9:
1503 case 10:
1504 case 11:
1505 case 12:
1506 case 13:
1507 case 14:
1508 case 15:
1509 case 16:
1510 case 17:
1511 case 18:
1512 case 19:
1513 case 20:
1514 case 21:
1515 case 22:
1516 case 23:
1517 case 24:
1518 case 25:
1519 case 26:
1520 case 27:
1521 case 30:
1522 case 31:
1523 case 32:
1524 case 33:
1525 case 34:
1526 case 35:
1527 case 36:
1528 case 37:
1529 case 38:
1530 case 39:
1531 case 40:
1532 case 41:
1533 case 42:
1534 case 43:
1535 case 44:
1536 case 45:
1537 case 46:
1538 case 47:
1539 case 48:
1540 case 49:
1541 case 50:
1542 case 51:
1543 case 52:
1544 case 53:
1545 case 54:
1546 case 55:
1547 {
1548 return 44;
1549 }
1550 case 29:
1551 {
1552 return 46;
1553 }
1554 default:
1555 {
1556 return -1;
1557 }
1558 }
1559 }
1560 case 13:
1561 {
1562 switch (i)
1563 {
1564 case 2:
1565 case 3:
1566 case 4:
1567 case 5:
1568 case 6:
1569 case 7:
1570 case 8:
1571 case 9:
1572 case 10:
1573 case 11:
1574 case 12:
1575 case 13:
1576 case 14:
1577 case 15:
1578 case 16:
1579 case 17:
1580 case 18:
1581 case 19:
1582 case 20:
1583 case 21:
1584 case 22:
1585 case 23:
1586 case 24:
1587 case 25:
1588 case 26:
1589 case 29:
1590 case 30:
1591 case 31:
1592 case 32:
1593 case 33:
1594 case 34:
1595 case 35:
1596 case 36:
1597 case 37:
1598 case 38:
1599 case 39:
1600 case 40:
1601 case 41:
1602 case 42:
1603 case 43:
1604 case 44:
1605 case 45:
1606 case 46:
1607 case 47:
1608 case 48:
1609 case 49:
1610 case 50:
1611 case 51:
1612 case 52:
1613 case 53:
1614 case 54:
1615 case 55:
1616 {
1617 return 69;
1618 }
1619 case 27:
1620 {
1621 return 70;
1622 }
1623 case 28:
1624 {
1625 return 71;
1626 }
1627 default:
1628 {
1629 return -1;
1630 }
1631 }
1632 }
1633 case 71:
1634 {
1635 switch (i)
1636 {
1637 case 9:
1638 {
1639 return 72;
1640 }
1641 case 10:
1642 {
1643 return 73;
1644 }
1645 case 11:
1646 {
1647 return 74;
1648 }
1649 case 12:
1650 {
1651 return 75;
1652 }
1653 case 22:
1654 {
1655 return 76;
1656 }
1657 case 23:
1658 {
1659 return 77;
1660 }
1661 case 25:
1662 case 26:
1663 {
1664 return 78;
1665 }
1666 case 27:
1667 case 28:
1668 case 29:
1669 case 30:
1670 case 31:
1671 case 32:
1672 case 33:
1673 case 34:
1674 case 35:
1675 case 36:
1676 {
1677 return 79;
1678 }
1679 default:
1680 {
1681 return -1;
1682 }
1683 }
1684 }
1685 case 79:
1686 {
1687 switch (i)
1688 {
1689 case 2:
1690 case 3:
1691 case 4:
1692 case 5:
1693 case 6:
1694 case 7:
1695 case 8:
1696 case 9:
1697 case 10:
1698 case 11:
1699 case 12:
1700 case 13:
1701 case 14:
1702 case 15:
1703 case 16:
1704 case 17:
1705 case 18:
1706 case 19:
1707 case 20:
1708 case 21:
1709 case 22:
1710 case 23:
1711 case 24:
1712 case 25:
1713 case 26:
1714 case 29:
1715 case 30:
1716 case 31:
1717 case 32:
1718 case 33:
1719 case 34:
1720 case 35:
1721 case 36:
1722 case 37:
1723 case 38:
1724 case 39:
1725 case 40:
1726 case 41:
1727 case 42:
1728 case 43:
1729 case 44:
1730 case 45:
1731 case 46:
1732 case 47:
1733 case 48:
1734 case 49:
1735 case 50:
1736 case 51:
1737 case 52:
1738 case 53:
1739 case 54:
1740 case 55:
1741 {
1742 return 69;
1743 }
1744 case 27:
1745 {
1746 return 70;
1747 }
1748 case 28:
1749 {
1750 return 71;
1751 }
1752 default:
1753 {
1754 return -1;
1755 }
1756 }
1757 }
1758 case 78:
1759 {
1760 switch (i)
1761 {
1762 case 2:
1763 case 3:
1764 case 4:
1765 case 5:
1766 case 6:
1767 case 7:
1768 case 8:
1769 case 9:
1770 case 10:
1771 case 11:
1772 case 12:
1773 case 13:
1774 case 14:
1775 case 15:
1776 case 16:
1777 case 17:
1778 case 18:
1779 case 19:
1780 case 20:
1781 case 21:
1782 case 22:
1783 case 23:
1784 case 24:
1785 case 29:
1786 case 30:
1787 case 31:
1788 case 32:
1789 case 33:
1790 case 34:
1791 case 35:
1792 case 36:
1793 case 37:
1794 case 38:
1795 case 39:
1796 case 40:
1797 case 41:
1798 case 42:
1799 case 43:
1800 case 44:
1801 case 45:
1802 case 46:
1803 case 47:
1804 case 48:
1805 case 49:
1806 case 50:
1807 case 51:
1808 case 52:
1809 case 53:
1810 case 54:
1811 case 55:
1812 {
1813 return 69;
1814 }
1815 case 27:
1816 {
1817 return 70;
1818 }
1819 case 28:
1820 {
1821 return 71;
1822 }
1823 case 25:
1824 case 26:
1825 {
1826 return 78;
1827 }
1828 default:
1829 {
1830 return -1;
1831 }
1832 }
1833 }
1834 case 77:
1835 {
1836 switch (i)
1837 {
1838 case 24:
1839 case 25:
1840 case 26:
1841 {
1842 return 80;
1843 }
1844 default:
1845 {
1846 return -1;
1847 }
1848 }
1849 }
1850 case 80:
1851 {
1852 switch (i)
1853 {
1854 case 2:
1855 case 3:
1856 case 4:
1857 case 5:
1858 case 6:
1859 case 7:
1860 case 8:
1861 case 9:
1862 case 10:
1863 case 11:
1864 case 12:
1865 case 13:
1866 case 14:
1867 case 15:
1868 case 16:
1869 case 17:
1870 case 18:
1871 case 19:
1872 case 20:
1873 case 21:
1874 case 22:
1875 case 23:
1876 case 29:
1877 case 30:
1878 case 31:
1879 case 32:
1880 case 33:
1881 case 34:
1882 case 35:
1883 case 36:
1884 case 37:
1885 case 38:
1886 case 39:
1887 case 40:
1888 case 41:
1889 case 42:
1890 case 43:
1891 case 44:
1892 case 45:
1893 case 46:
1894 case 47:
1895 case 48:
1896 case 49:
1897 case 50:
1898 case 51:
1899 case 52:
1900 case 53:
1901 case 54:
1902 case 55:
1903 {
1904 return 69;
1905 }
1906 case 27:
1907 {
1908 return 70;
1909 }
1910 case 28:
1911 {
1912 return 71;
1913 }
1914 case 24:
1915 case 25:
1916 case 26:
1917 {
1918 return 80;
1919 }
1920 default:
1921 {
1922 return -1;
1923 }
1924 }
1925 }
1926 case 76:
1927 {
1928 switch (i)
1929 {
1930 case 24:
1931 case 25:
1932 case 26:
1933 {
1934 return 80;
1935 }
1936 default:
1937 {
1938 return -1;
1939 }
1940 }
1941 }
1942 case 75:
1943 {
1944 switch (i)
1945 {
1946 case 18:
1947 case 19:
1948 case 20:
1949 case 21:
1950 case 22:
1951 case 23:
1952 case 24:
1953 case 25:
1954 case 26:
1955 case 34:
1956 case 35:
1957 case 36:
1958 {
1959 return 81;
1960 }
1961 default:
1962 {
1963 return -1;
1964 }
1965 }
1966 }
1967 case 81:
1968 {
1969 switch (i)
1970 {
1971 case 18:
1972 case 19:
1973 case 20:
1974 case 21:
1975 case 22:
1976 case 23:
1977 case 24:
1978 case 25:
1979 case 26:
1980 case 34:
1981 case 35:
1982 case 36:
1983 {
1984 return 82;
1985 }
1986 default:
1987 {
1988 return -1;
1989 }
1990 }
1991 }
1992 case 82:
1993 {
1994 switch (i)
1995 {
1996 case 18:
1997 case 19:
1998 case 20:
1999 case 21:
2000 case 22:
2001 case 23:
2002 case 24:
2003 case 25:
2004 case 26:
2005 case 34:
2006 case 35:
2007 case 36:
2008 {
2009 return 83;
2010 }
2011 default:
2012 {
2013 return -1;
2014 }
2015 }
2016 }
2017 case 83:
2018 {
2019 switch (i)
2020 {
2021 case 18:
2022 case 19:
2023 case 20:
2024 case 21:
2025 case 22:
2026 case 23:
2027 case 24:
2028 case 25:
2029 case 26:
2030 case 34:
2031 case 35:
2032 case 36:
2033 {
2034 return 84;
2035 }
2036 default:
2037 {
2038 return -1;
2039 }
2040 }
2041 }
2042 case 84:
2043 {
2044 switch (i)
2045 {
2046 case 18:
2047 case 19:
2048 case 20:
2049 case 21:
2050 case 22:
2051 case 23:
2052 case 24:
2053 case 25:
2054 case 26:
2055 case 34:
2056 case 35:
2057 case 36:
2058 {
2059 return 85;
2060 }
2061 default:
2062 {
2063 return -1;
2064 }
2065 }
2066 }
2067 case 85:
2068 {
2069 switch (i)
2070 {
2071 case 18:
2072 case 19:
2073 case 20:
2074 case 21:
2075 case 22:
2076 case 23:
2077 case 24:
2078 case 25:
2079 case 26:
2080 case 34:
2081 case 35:
2082 case 36:
2083 {
2084 return 86;
2085 }
2086 default:
2087 {
2088 return -1;
2089 }
2090 }
2091 }
2092 case 86:
2093 {
2094 switch (i)
2095 {
2096 case 18:
2097 case 19:
2098 case 20:
2099 case 21:
2100 case 22:
2101 case 23:
2102 case 24:
2103 case 25:
2104 case 26:
2105 case 34:
2106 case 35:
2107 case 36:
2108 {
2109 return 87;
2110 }
2111 default:
2112 {
2113 return -1;
2114 }
2115 }
2116 }
2117 case 87:
2118 {
2119 switch (i)
2120 {
2121 case 18:
2122 case 19:
2123 case 20:
2124 case 21:
2125 case 22:
2126 case 23:
2127 case 24:
2128 case 25:
2129 case 26:
2130 case 34:
2131 case 35:
2132 case 36:
2133 {
2134 return 88;
2135 }
2136 default:
2137 {
2138 return -1;
2139 }
2140 }
2141 }
2142 case 88:
2143 {
2144 switch (i)
2145 {
2146 case 2:
2147 case 3:
2148 case 4:
2149 case 5:
2150 case 6:
2151 case 7:
2152 case 8:
2153 case 9:
2154 case 10:
2155 case 11:
2156 case 12:
2157 case 13:
2158 case 14:
2159 case 15:
2160 case 16:
2161 case 17:
2162 case 18:
2163 case 19:
2164 case 20:
2165 case 21:
2166 case 22:
2167 case 23:
2168 case 24:
2169 case 25:
2170 case 26:
2171 case 29:
2172 case 30:
2173 case 31:
2174 case 32:
2175 case 33:
2176 case 34:
2177 case 35:
2178 case 36:
2179 case 37:
2180 case 38:
2181 case 39:
2182 case 40:
2183 case 41:
2184 case 42:
2185 case 43:
2186 case 44:
2187 case 45:
2188 case 46:
2189 case 47:
2190 case 48:
2191 case 49:
2192 case 50:
2193 case 51:
2194 case 52:
2195 case 53:
2196 case 54:
2197 case 55:
2198 {
2199 return 69;
2200 }
2201 case 27:
2202 {
2203 return 70;
2204 }
2205 case 28:
2206 {
2207 return 71;
2208 }
2209 default:
2210 {
2211 return -1;
2212 }
2213 }
2214 }
2215 case 74:
2216 {
2217 switch (i)
2218 {
2219 case 18:
2220 case 19:
2221 case 20:
2222 case 21:
2223 case 22:
2224 case 23:
2225 case 24:
2226 case 25:
2227 case 26:
2228 case 34:
2229 case 35:
2230 case 36:
2231 {
2232 return 89;
2233 }
2234 default:
2235 {
2236 return -1;
2237 }
2238 }
2239 }
2240 case 89:
2241 {
2242 switch (i)
2243 {
2244 case 18:
2245 case 19:
2246 case 20:
2247 case 21:
2248 case 22:
2249 case 23:
2250 case 24:
2251 case 25:
2252 case 26:
2253 case 34:
2254 case 35:
2255 case 36:
2256 {
2257 return 90;
2258 }
2259 default:
2260 {
2261 return -1;
2262 }
2263 }
2264 }
2265 case 90:
2266 {
2267 switch (i)
2268 {
2269 case 18:
2270 case 19:
2271 case 20:
2272 case 21:
2273 case 22:
2274 case 23:
2275 case 24:
2276 case 25:
2277 case 26:
2278 case 34:
2279 case 35:
2280 case 36:
2281 {
2282 return 91;
2283 }
2284 default:
2285 {
2286 return -1;
2287 }
2288 }
2289 }
2290 case 91:
2291 {
2292 switch (i)
2293 {
2294 case 18:
2295 case 19:
2296 case 20:
2297 case 21:
2298 case 22:
2299 case 23:
2300 case 24:
2301 case 25:
2302 case 26:
2303 case 34:
2304 case 35:
2305 case 36:
2306 {
2307 return 92;
2308 }
2309 default:
2310 {
2311 return -1;
2312 }
2313 }
2314 }
2315 case 92:
2316 {
2317 switch (i)
2318 {
2319 case 2:
2320 case 3:
2321 case 4:
2322 case 5:
2323 case 6:
2324 case 7:
2325 case 8:
2326 case 9:
2327 case 10:
2328 case 11:
2329 case 12:
2330 case 13:
2331 case 14:
2332 case 15:
2333 case 16:
2334 case 17:
2335 case 18:
2336 case 19:
2337 case 20:
2338 case 21:
2339 case 22:
2340 case 23:
2341 case 24:
2342 case 25:
2343 case 26:
2344 case 29:
2345 case 30:
2346 case 31:
2347 case 32:
2348 case 33:
2349 case 34:
2350 case 35:
2351 case 36:
2352 case 37:
2353 case 38:
2354 case 39:
2355 case 40:
2356 case 41:
2357 case 42:
2358 case 43:
2359 case 44:
2360 case 45:
2361 case 46:
2362 case 47:
2363 case 48:
2364 case 49:
2365 case 50:
2366 case 51:
2367 case 52:
2368 case 53:
2369 case 54:
2370 case 55:
2371 {
2372 return 69;
2373 }
2374 case 27:
2375 {
2376 return 70;
2377 }
2378 case 28:
2379 {
2380 return 71;
2381 }
2382 default:
2383 {
2384 return -1;
2385 }
2386 }
2387 }
2388 case 73:
2389 {
2390 switch (i)
2391 {
2392 case 18:
2393 case 19:
2394 case 20:
2395 case 21:
2396 case 22:
2397 case 23:
2398 case 24:
2399 case 25:
2400 case 26:
2401 case 34:
2402 case 35:
2403 case 36:
2404 {
2405 return 93;
2406 }
2407 default:
2408 {
2409 return -1;
2410 }
2411 }
2412 }
2413 case 93:
2414 {
2415 switch (i)
2416 {
2417 case 2:
2418 case 3:
2419 case 4:
2420 case 5:
2421 case 6:
2422 case 7:
2423 case 8:
2424 case 9:
2425 case 10:
2426 case 11:
2427 case 12:
2428 case 13:
2429 case 14:
2430 case 15:
2431 case 16:
2432 case 17:
2433 case 29:
2434 case 30:
2435 case 31:
2436 case 32:
2437 case 33:
2438 case 37:
2439 case 38:
2440 case 39:
2441 case 40:
2442 case 41:
2443 case 42:
2444 case 43:
2445 case 44:
2446 case 45:
2447 case 46:
2448 case 47:
2449 case 48:
2450 case 49:
2451 case 50:
2452 case 51:
2453 case 52:
2454 case 53:
2455 case 54:
2456 case 55:
2457 {
2458 return 69;
2459 }
2460 case 27:
2461 {
2462 return 70;
2463 }
2464 case 28:
2465 {
2466 return 71;
2467 }
2468 case 18:
2469 case 19:
2470 case 20:
2471 case 21:
2472 case 22:
2473 case 23:
2474 case 24:
2475 case 25:
2476 case 26:
2477 case 34:
2478 case 35:
2479 case 36:
2480 {
2481 return 93;
2482 }
2483 default:
2484 {
2485 return -1;
2486 }
2487 }
2488 }
2489 case 72:
2490 {
2491 switch (i)
2492 {
2493 case 18:
2494 case 19:
2495 case 20:
2496 case 21:
2497 case 22:
2498 case 23:
2499 case 24:
2500 case 25:
2501 case 26:
2502 case 34:
2503 case 35:
2504 case 36:
2505 {
2506 return 93;
2507 }
2508 default:
2509 {
2510 return -1;
2511 }
2512 }
2513 }
2514 case 70:
2515 {
2516 Lexeme prevMatch = token.match;
2517 token.match = lexeme;
2518 int tokenId = GetTokenId(5);
2519 if (tokenId == CONTINUE_TOKEN)
2520 {
2521 token.id = tokenId;
2522 return -1;
2523 }
2524 else if (tokenId != INVALID_TOKEN)
2525 {
2526 token.id = tokenId;
2527 }
2528 else
2529 {
2530 token.match = prevMatch;
2531 }
2532 return -1;
2533 }
2534 case 69:
2535 {
2536 switch (i)
2537 {
2538 case 2:
2539 case 3:
2540 case 4:
2541 case 5:
2542 case 6:
2543 case 7:
2544 case 8:
2545 case 9:
2546 case 10:
2547 case 11:
2548 case 12:
2549 case 13:
2550 case 14:
2551 case 15:
2552 case 16:
2553 case 17:
2554 case 18:
2555 case 19:
2556 case 20:
2557 case 21:
2558 case 22:
2559 case 23:
2560 case 24:
2561 case 25:
2562 case 26:
2563 case 29:
2564 case 30:
2565 case 31:
2566 case 32:
2567 case 33:
2568 case 34:
2569 case 35:
2570 case 36:
2571 case 37:
2572 case 38:
2573 case 39:
2574 case 40:
2575 case 41:
2576 case 42:
2577 case 43:
2578 case 44:
2579 case 45:
2580 case 46:
2581 case 47:
2582 case 48:
2583 case 49:
2584 case 50:
2585 case 51:
2586 case 52:
2587 case 53:
2588 case 54:
2589 case 55:
2590 {
2591 return 69;
2592 }
2593 case 27:
2594 {
2595 return 70;
2596 }
2597 case 28:
2598 {
2599 return 71;
2600 }
2601 default:
2602 {
2603 return -1;
2604 }
2605 }
2606 }
2607 case 12:
2608 {
2609 Lexeme prevMatch = token.match;
2610 token.match = lexeme;
2611 int tokenId = GetTokenId(2);
2612 if (tokenId == CONTINUE_TOKEN)
2613 {
2614 token.id = tokenId;
2615 return -1;
2616 }
2617 else if (tokenId != INVALID_TOKEN)
2618 {
2619 token.id = tokenId;
2620 }
2621 else
2622 {
2623 token.match = prevMatch;
2624 }
2625 switch (i)
2626 {
2627 case 9:
2628 {
2629 return 94;
2630 }
2631 case 10:
2632 {
2633 return 95;
2634 }
2635 case 11:
2636 {
2637 return 96;
2638 }
2639 case 12:
2640 {
2641 return 97;
2642 }
2643 case 13:
2644 {
2645 return 98;
2646 }
2647 case 19:
2648 {
2649 return 99;
2650 }
2651 case 20:
2652 {
2653 return 100;
2654 }
2655 case 24:
2656 {
2657 return 101;
2658 }
2659 case 25:
2660 case 26:
2661 {
2662 return 102;
2663 }
2664 default:
2665 {
2666 return -1;
2667 }
2668 }
2669 }
2670 case 102:
2671 {
2672 Lexeme prevMatch = token.match;
2673 token.match = lexeme;
2674 int tokenId = GetTokenId(2);
2675 if (tokenId == CONTINUE_TOKEN)
2676 {
2677 token.id = tokenId;
2678 return -1;
2679 }
2680 else if (tokenId != INVALID_TOKEN)
2681 {
2682 token.id = tokenId;
2683 }
2684 else
2685 {
2686 token.match = prevMatch;
2687 }
2688 switch (i)
2689 {
2690 case 11:
2691 {
2692 return 96;
2693 }
2694 case 12:
2695 {
2696 return 97;
2697 }
2698 case 13:
2699 {
2700 return 98;
2701 }
2702 case 19:
2703 {
2704 return 99;
2705 }
2706 case 20:
2707 {
2708 return 100;
2709 }
2710 case 24:
2711 {
2712 return 101;
2713 }
2714 case 25:
2715 case 26:
2716 {
2717 return 102;
2718 }
2719 default:
2720 {
2721 return -1;
2722 }
2723 }
2724 }
2725 case 101:
2726 {
2727 switch (i)
2728 {
2729 case 13:
2730 {
2731 return 98;
2732 }
2733 case 19:
2734 {
2735 return 99;
2736 }
2737 case 20:
2738 {
2739 return 100;
2740 }
2741 case 24:
2742 case 25:
2743 case 26:
2744 {
2745 return 101;
2746 }
2747 default:
2748 {
2749 return -1;
2750 }
2751 }
2752 }
2753 case 100:
2754 {
2755 switch (i)
2756 {
2757 case 14:
2758 {
2759 return 103;
2760 }
2761 case 15:
2762 {
2763 return 104;
2764 }
2765 case 24:
2766 case 25:
2767 case 26:
2768 {
2769 return 105;
2770 }
2771 default:
2772 {
2773 return -1;
2774 }
2775 }
2776 }
2777 case 105:
2778 {
2779 Lexeme prevMatch = token.match;
2780 token.match = lexeme;
2781 int tokenId = GetTokenId(3);
2782 if (tokenId == CONTINUE_TOKEN)
2783 {
2784 token.id = tokenId;
2785 return -1;
2786 }
2787 else if (tokenId != INVALID_TOKEN)
2788 {
2789 token.id = tokenId;
2790 }
2791 else
2792 {
2793 token.match = prevMatch;
2794 }
2795 switch (i)
2796 {
2797 case 24:
2798 case 25:
2799 case 26:
2800 {
2801 return 105;
2802 }
2803 case 21:
2804 {
2805 return 106;
2806 }
2807 case 34:
2808 {
2809 return 107;
2810 }
2811 default:
2812 {
2813 return -1;
2814 }
2815 }
2816 }
2817 case 107:
2818 {
2819 Lexeme prevMatch = token.match;
2820 token.match = lexeme;
2821 int tokenId = GetTokenId(3);
2822 if (tokenId == CONTINUE_TOKEN)
2823 {
2824 token.id = tokenId;
2825 return -1;
2826 }
2827 else if (tokenId != INVALID_TOKEN)
2828 {
2829 token.id = tokenId;
2830 }
2831 else
2832 {
2833 token.match = prevMatch;
2834 }
2835 return -1;
2836 }
2837 case 106:
2838 {
2839 Lexeme prevMatch = token.match;
2840 token.match = lexeme;
2841 int tokenId = GetTokenId(3);
2842 if (tokenId == CONTINUE_TOKEN)
2843 {
2844 token.id = tokenId;
2845 return -1;
2846 }
2847 else if (tokenId != INVALID_TOKEN)
2848 {
2849 token.id = tokenId;
2850 }
2851 else
2852 {
2853 token.match = prevMatch;
2854 }
2855 return -1;
2856 }
2857 case 104:
2858 {
2859 switch (i)
2860 {
2861 case 24:
2862 case 25:
2863 case 26:
2864 {
2865 return 105;
2866 }
2867 default:
2868 {
2869 return -1;
2870 }
2871 }
2872 }
2873 case 103:
2874 {
2875 switch (i)
2876 {
2877 case 24:
2878 case 25:
2879 case 26:
2880 {
2881 return 105;
2882 }
2883 default:
2884 {
2885 return -1;
2886 }
2887 }
2888 }
2889 case 99:
2890 {
2891 switch (i)
2892 {
2893 case 14:
2894 {
2895 return 103;
2896 }
2897 case 15:
2898 {
2899 return 104;
2900 }
2901 case 24:
2902 case 25:
2903 case 26:
2904 {
2905 return 105;
2906 }
2907 default:
2908 {
2909 return -1;
2910 }
2911 }
2912 }
2913 case 98:
2914 {
2915 Lexeme prevMatch = token.match;
2916 token.match = lexeme;
2917 int tokenId = GetTokenId(3);
2918 if (tokenId == CONTINUE_TOKEN)
2919 {
2920 token.id = tokenId;
2921 return -1;
2922 }
2923 else if (tokenId != INVALID_TOKEN)
2924 {
2925 token.id = tokenId;
2926 }
2927 else
2928 {
2929 token.match = prevMatch;
2930 }
2931 switch (i)
2932 {
2933 case 21:
2934 {
2935 return 106;
2936 }
2937 case 34:
2938 {
2939 return 107;
2940 }
2941 case 19:
2942 {
2943 return 108;
2944 }
2945 case 20:
2946 {
2947 return 109;
2948 }
2949 case 24:
2950 case 25:
2951 case 26:
2952 {
2953 return 110;
2954 }
2955 default:
2956 {
2957 return -1;
2958 }
2959 }
2960 }
2961 case 110:
2962 {
2963 Lexeme prevMatch = token.match;
2964 token.match = lexeme;
2965 int tokenId = GetTokenId(3);
2966 if (tokenId == CONTINUE_TOKEN)
2967 {
2968 token.id = tokenId;
2969 return -1;
2970 }
2971 else if (tokenId != INVALID_TOKEN)
2972 {
2973 token.id = tokenId;
2974 }
2975 else
2976 {
2977 token.match = prevMatch;
2978 }
2979 switch (i)
2980 {
2981 case 21:
2982 {
2983 return 106;
2984 }
2985 case 34:
2986 {
2987 return 107;
2988 }
2989 case 19:
2990 {
2991 return 108;
2992 }
2993 case 20:
2994 {
2995 return 109;
2996 }
2997 case 24:
2998 case 25:
2999 case 26:
3000 {
3001 return 110;
3002 }
3003 default:
3004 {
3005 return -1;
3006 }
3007 }
3008 }
3009 case 109:
3010 {
3011 switch (i)
3012 {
3013 case 14:
3014 {
3015 return 111;
3016 }
3017 case 15:
3018 {
3019 return 112;
3020 }
3021 case 24:
3022 case 25:
3023 case 26:
3024 {
3025 return 113;
3026 }
3027 default:
3028 {
3029 return -1;
3030 }
3031 }
3032 }
3033 case 113:
3034 {
3035 Lexeme prevMatch = token.match;
3036 token.match = lexeme;
3037 int tokenId = GetTokenId(3);
3038 if (tokenId == CONTINUE_TOKEN)
3039 {
3040 token.id = tokenId;
3041 return -1;
3042 }
3043 else if (tokenId != INVALID_TOKEN)
3044 {
3045 token.id = tokenId;
3046 }
3047 else
3048 {
3049 token.match = prevMatch;
3050 }
3051 switch (i)
3052 {
3053 case 21:
3054 {
3055 return 106;
3056 }
3057 case 34:
3058 {
3059 return 107;
3060 }
3061 case 24:
3062 case 25:
3063 case 26:
3064 {
3065 return 113;
3066 }
3067 default:
3068 {
3069 return -1;
3070 }
3071 }
3072 }
3073 case 112:
3074 {
3075 switch (i)
3076 {
3077 case 24:
3078 case 25:
3079 case 26:
3080 {
3081 return 113;
3082 }
3083 default:
3084 {
3085 return -1;
3086 }
3087 }
3088 }
3089 case 111:
3090 {
3091 switch (i)
3092 {
3093 case 24:
3094 case 25:
3095 case 26:
3096 {
3097 return 113;
3098 }
3099 default:
3100 {
3101 return -1;
3102 }
3103 }
3104 }
3105 case 108:
3106 {
3107 switch (i)
3108 {
3109 case 14:
3110 {
3111 return 111;
3112 }
3113 case 15:
3114 {
3115 return 112;
3116 }
3117 case 24:
3118 case 25:
3119 case 26:
3120 {
3121 return 113;
3122 }
3123 default:
3124 {
3125 return -1;
3126 }
3127 }
3128 }
3129 case 97:
3130 {
3131 Lexeme prevMatch = token.match;
3132 token.match = lexeme;
3133 int tokenId = GetTokenId(2);
3134 if (tokenId == CONTINUE_TOKEN)
3135 {
3136 token.id = tokenId;
3137 return -1;
3138 }
3139 else if (tokenId != INVALID_TOKEN)
3140 {
3141 token.id = tokenId;
3142 }
3143 else
3144 {
3145 token.match = prevMatch;
3146 }
3147 return -1;
3148 }
3149 case 96:
3150 {
3151 Lexeme prevMatch = token.match;
3152 token.match = lexeme;
3153 int tokenId = GetTokenId(2);
3154 if (tokenId == CONTINUE_TOKEN)
3155 {
3156 token.id = tokenId;
3157 return -1;
3158 }
3159 else if (tokenId != INVALID_TOKEN)
3160 {
3161 token.id = tokenId;
3162 }
3163 else
3164 {
3165 token.match = prevMatch;
3166 }
3167 return -1;
3168 }
3169 case 95:
3170 {
3171 switch (i)
3172 {
3173 case 18:
3174 case 19:
3175 case 20:
3176 case 21:
3177 case 22:
3178 case 23:
3179 case 24:
3180 case 25:
3181 case 26:
3182 case 34:
3183 case 35:
3184 case 36:
3185 {
3186 return 114;
3187 }
3188 default:
3189 {
3190 return -1;
3191 }
3192 }
3193 }
3194 case 114:
3195 {
3196 Lexeme prevMatch = token.match;
3197 token.match = lexeme;
3198 int tokenId = GetTokenId(2);
3199 if (tokenId == CONTINUE_TOKEN)
3200 {
3201 token.id = tokenId;
3202 return -1;
3203 }
3204 else if (tokenId != INVALID_TOKEN)
3205 {
3206 token.id = tokenId;
3207 }
3208 else
3209 {
3210 token.match = prevMatch;
3211 }
3212 switch (i)
3213 {
3214 case 11:
3215 {
3216 return 96;
3217 }
3218 case 12:
3219 {
3220 return 97;
3221 }
3222 case 18:
3223 case 19:
3224 case 20:
3225 case 21:
3226 case 22:
3227 case 23:
3228 case 24:
3229 case 25:
3230 case 26:
3231 case 34:
3232 case 35:
3233 case 36:
3234 {
3235 return 114;
3236 }
3237 default:
3238 {
3239 return -1;
3240 }
3241 }
3242 }
3243 case 94:
3244 {
3245 switch (i)
3246 {
3247 case 18:
3248 case 19:
3249 case 20:
3250 case 21:
3251 case 22:
3252 case 23:
3253 case 24:
3254 case 25:
3255 case 26:
3256 case 34:
3257 case 35:
3258 case 36:
3259 {
3260 return 114;
3261 }
3262 default:
3263 {
3264 return -1;
3265 }
3266 }
3267 }
3268 case 11:
3269 {
3270 Lexeme prevMatch = token.match;
3271 token.match = lexeme;
3272 int tokenId = GetTokenId(2);
3273 if (tokenId == CONTINUE_TOKEN)
3274 {
3275 token.id = tokenId;
3276 return -1;
3277 }
3278 else if (tokenId != INVALID_TOKEN)
3279 {
3280 token.id = tokenId;
3281 }
3282 else
3283 {
3284 token.match = prevMatch;
3285 }
3286 switch (i)
3287 {
3288 case 11:
3289 {
3290 return 96;
3291 }
3292 case 12:
3293 {
3294 return 97;
3295 }
3296 case 13:
3297 {
3298 return 98;
3299 }
3300 case 19:
3301 {
3302 return 99;
3303 }
3304 case 20:
3305 {
3306 return 100;
3307 }
3308 case 24:
3309 case 25:
3310 case 26:
3311 {
3312 return 115;
3313 }
3314 default:
3315 {
3316 return -1;
3317 }
3318 }
3319 }
3320 case 115:
3321 {
3322 Lexeme prevMatch = token.match;
3323 token.match = lexeme;
3324 int tokenId = GetTokenId(2);
3325 if (tokenId == CONTINUE_TOKEN)
3326 {
3327 token.id = tokenId;
3328 return -1;
3329 }
3330 else if (tokenId != INVALID_TOKEN)
3331 {
3332 token.id = tokenId;
3333 }
3334 else
3335 {
3336 token.match = prevMatch;
3337 }
3338 switch (i)
3339 {
3340 case 11:
3341 {
3342 return 96;
3343 }
3344 case 12:
3345 {
3346 return 97;
3347 }
3348 case 13:
3349 {
3350 return 98;
3351 }
3352 case 19:
3353 {
3354 return 99;
3355 }
3356 case 20:
3357 {
3358 return 100;
3359 }
3360 case 24:
3361 case 25:
3362 case 26:
3363 {
3364 return 115;
3365 }
3366 default:
3367 {
3368 return -1;
3369 }
3370 }
3371 }
3372 case 10:
3373 {
3374 switch (i)
3375 {
3376 case 27:
3377 {
3378 return 116;
3379 }
3380 default:
3381 {
3382 return -1;
3383 }
3384 }
3385 }
3386 case 116:
3387 {
3388 switch (i)
3389 {
3390 case 0:
3391 case 1:
3392 case 2:
3393 case 3:
3394 case 4:
3395 case 5:
3396 case 6:
3397 case 7:
3398 case 8:
3399 case 9:
3400 case 10:
3401 case 11:
3402 case 12:
3403 case 13:
3404 case 14:
3405 case 15:
3406 case 16:
3407 case 17:
3408 case 18:
3409 case 19:
3410 case 20:
3411 case 21:
3412 case 22:
3413 case 23:
3414 case 24:
3415 case 25:
3416 case 26:
3417 case 28:
3418 case 29:
3419 case 30:
3420 case 31:
3421 case 32:
3422 case 33:
3423 case 34:
3424 case 35:
3425 case 36:
3426 case 37:
3427 case 38:
3428 case 39:
3429 case 40:
3430 case 41:
3431 case 42:
3432 case 43:
3433 case 44:
3434 case 45:
3435 case 46:
3436 case 47:
3437 case 48:
3438 case 49:
3439 case 50:
3440 case 51:
3441 case 52:
3442 case 53:
3443 case 54:
3444 case 55:
3445 {
3446 return 117;
3447 }
3448 case 27:
3449 {
3450 return 118;
3451 }
3452 default:
3453 {
3454 return -1;
3455 }
3456 }
3457 }
3458 case 118:
3459 {
3460 Lexeme prevMatch = token.match;
3461 token.match = lexeme;
3462 int tokenId = GetTokenId(5);
3463 if (tokenId == CONTINUE_TOKEN)
3464 {
3465 token.id = tokenId;
3466 return -1;
3467 }
3468 else if (tokenId != INVALID_TOKEN)
3469 {
3470 token.id = tokenId;
3471 }
3472 else
3473 {
3474 token.match = prevMatch;
3475 }
3476 return -1;
3477 }
3478 case 117:
3479 {
3480 switch (i)
3481 {
3482 case 0:
3483 case 1:
3484 case 2:
3485 case 3:
3486 case 4:
3487 case 5:
3488 case 6:
3489 case 7:
3490 case 8:
3491 case 9:
3492 case 10:
3493 case 11:
3494 case 12:
3495 case 13:
3496 case 14:
3497 case 15:
3498 case 16:
3499 case 17:
3500 case 18:
3501 case 19:
3502 case 20:
3503 case 21:
3504 case 22:
3505 case 23:
3506 case 24:
3507 case 25:
3508 case 26:
3509 case 28:
3510 case 29:
3511 case 30:
3512 case 31:
3513 case 32:
3514 case 33:
3515 case 34:
3516 case 35:
3517 case 36:
3518 case 37:
3519 case 38:
3520 case 39:
3521 case 40:
3522 case 41:
3523 case 42:
3524 case 43:
3525 case 44:
3526 case 45:
3527 case 46:
3528 case 47:
3529 case 48:
3530 case 49:
3531 case 50:
3532 case 51:
3533 case 52:
3534 case 53:
3535 case 54:
3536 case 55:
3537 {
3538 return 117;
3539 }
3540 case 27:
3541 {
3542 return 118;
3543 }
3544 default:
3545 {
3546 return -1;
3547 }
3548 }
3549 }
3550 case 9:
3551 {
3552 Lexeme prevMatch = token.match;
3553 token.match = lexeme;
3554 int tokenId = GetTokenId(1);
3555 if (tokenId == CONTINUE_TOKEN)
3556 {
3557 token.id = tokenId;
3558 return -1;
3559 }
3560 else if (tokenId != INVALID_TOKEN)
3561 {
3562 token.id = tokenId;
3563 }
3564 else
3565 {
3566 token.match = prevMatch;
3567 }
3568 switch (i)
3569 {
3570 case 17:
3571 {
3572 return 10;
3573 }
3574 case 27:
3575 {
3576 return 13;
3577 }
3578 case 29:
3579 {
3580 return 14;
3581 }
3582 case 4:
3583 case 5:
3584 case 9:
3585 case 10:
3586 case 11:
3587 case 12:
3588 case 16:
3589 case 18:
3590 case 19:
3591 case 20:
3592 case 21:
3593 case 22:
3594 case 23:
3595 case 24:
3596 case 25:
3597 case 26:
3598 case 30:
3599 case 31:
3600 case 32:
3601 case 33:
3602 case 34:
3603 case 35:
3604 case 36:
3605 {
3606 return 119;
3607 }
3608 default:
3609 {
3610 return -1;
3611 }
3612 }
3613 }
3614 case 119:
3615 {
3616 Lexeme prevMatch = token.match;
3617 token.match = lexeme;
3618 int tokenId = GetTokenId(1);
3619 if (tokenId == CONTINUE_TOKEN)
3620 {
3621 token.id = tokenId;
3622 return -1;
3623 }
3624 else if (tokenId != INVALID_TOKEN)
3625 {
3626 token.id = tokenId;
3627 }
3628 else
3629 {
3630 token.match = prevMatch;
3631 }
3632 switch (i)
3633 {
3634 case 4:
3635 case 5:
3636 case 9:
3637 case 10:
3638 case 11:
3639 case 12:
3640 case 16:
3641 case 18:
3642 case 19:
3643 case 20:
3644 case 21:
3645 case 22:
3646 case 23:
3647 case 24:
3648 case 25:
3649 case 26:
3650 case 30:
3651 case 31:
3652 case 32:
3653 case 33:
3654 case 34:
3655 case 35:
3656 case 36:
3657 {
3658 return 119;
3659 }
3660 default:
3661 {
3662 return -1;
3663 }
3664 }
3665 }
3666 case 8:
3667 {
3668 Lexeme prevMatch = token.match;
3669 token.match = lexeme;
3670 int tokenId = GetTokenId(22);
3671 if (tokenId == CONTINUE_TOKEN)
3672 {
3673 token.id = tokenId;
3674 return -1;
3675 }
3676 else if (tokenId != INVALID_TOKEN)
3677 {
3678 token.id = tokenId;
3679 }
3680 else
3681 {
3682 token.match = prevMatch;
3683 }
3684 switch (i)
3685 {
3686 case 15:
3687 {
3688 return 120;
3689 }
3690 case 39:
3691 {
3692 return 121;
3693 }
3694 default:
3695 {
3696 return -1;
3697 }
3698 }
3699 }
3700 case 121:
3701 {
3702 Lexeme prevMatch = token.match;
3703 token.match = lexeme;
3704 int tokenId = GetTokenId(31);
3705 if (tokenId == CONTINUE_TOKEN)
3706 {
3707 token.id = tokenId;
3708 return -1;
3709 }
3710 else if (tokenId != INVALID_TOKEN)
3711 {
3712 token.id = tokenId;
3713 }
3714 else
3715 {
3716 token.match = prevMatch;
3717 }
3718 return -1;
3719 }
3720 case 120:
3721 {
3722 Lexeme prevMatch = token.match;
3723 token.match = lexeme;
3724 int tokenId = GetTokenId(27);
3725 if (tokenId == CONTINUE_TOKEN)
3726 {
3727 token.id = tokenId;
3728 return -1;
3729 }
3730 else if (tokenId != INVALID_TOKEN)
3731 {
3732 token.id = tokenId;
3733 }
3734 else
3735 {
3736 token.match = prevMatch;
3737 }
3738 return -1;
3739 }
3740 case 7:
3741 {
3742 Lexeme prevMatch = token.match;
3743 token.match = lexeme;
3744 int tokenId = GetTokenId(21);
3745 if (tokenId == CONTINUE_TOKEN)
3746 {
3747 token.id = tokenId;
3748 return -1;
3749 }
3750 else if (tokenId != INVALID_TOKEN)
3751 {
3752 token.id = tokenId;
3753 }
3754 else
3755 {
3756 token.match = prevMatch;
3757 }
3758 switch (i)
3759 {
3760 case 14:
3761 {
3762 return 122;
3763 }
3764 default:
3765 {
3766 return -1;
3767 }
3768 }
3769 }
3770 case 122:
3771 {
3772 Lexeme prevMatch = token.match;
3773 token.match = lexeme;
3774 int tokenId = GetTokenId(26);
3775 if (tokenId == CONTINUE_TOKEN)
3776 {
3777 token.id = tokenId;
3778 return -1;
3779 }
3780 else if (tokenId != INVALID_TOKEN)
3781 {
3782 token.id = tokenId;
3783 }
3784 else
3785 {
3786 token.match = prevMatch;
3787 }
3788 return -1;
3789 }
3790 case 6:
3791 {
3792 Lexeme prevMatch = token.match;
3793 token.match = lexeme;
3794 int tokenId = GetTokenId(30);
3795 if (tokenId == CONTINUE_TOKEN)
3796 {
3797 token.id = tokenId;
3798 return -1;
3799 }
3800 else if (tokenId != INVALID_TOKEN)
3801 {
3802 token.id = tokenId;
3803 }
3804 else
3805 {
3806 token.match = prevMatch;
3807 }
3808 switch (i)
3809 {
3810 case 24:
3811 case 25:
3812 case 26:
3813 {
3814 return 110;
3815 }
3816 default:
3817 {
3818 return -1;
3819 }
3820 }
3821 }
3822 case 5:
3823 {
3824 Lexeme prevMatch = token.match;
3825 token.match = lexeme;
3826 int tokenId = GetTokenId(1);
3827 if (tokenId == CONTINUE_TOKEN)
3828 {
3829 token.id = tokenId;
3830 return -1;
3831 }
3832 else if (tokenId != INVALID_TOKEN)
3833 {
3834 token.id = tokenId;
3835 }
3836 else
3837 {
3838 token.match = prevMatch;
3839 }
3840 switch (i)
3841 {
3842 case 17:
3843 {
3844 return 10;
3845 }
3846 case 27:
3847 {
3848 return 13;
3849 }
3850 case 29:
3851 {
3852 return 14;
3853 }
3854 case 4:
3855 case 5:
3856 case 9:
3857 case 10:
3858 case 11:
3859 case 12:
3860 case 16:
3861 case 18:
3862 case 19:
3863 case 20:
3864 case 21:
3865 case 22:
3866 case 23:
3867 case 24:
3868 case 25:
3869 case 26:
3870 case 30:
3871 case 31:
3872 case 32:
3873 case 33:
3874 case 34:
3875 case 35:
3876 case 36:
3877 {
3878 return 119;
3879 }
3880 default:
3881 {
3882 return -1;
3883 }
3884 }
3885 }
3886 case 4:
3887 {
3888 Lexeme prevMatch = token.match;
3889 token.match = lexeme;
3890 int tokenId = GetTokenId(1);
3891 if (tokenId == CONTINUE_TOKEN)
3892 {
3893 token.id = tokenId;
3894 return -1;
3895 }
3896 else if (tokenId != INVALID_TOKEN)
3897 {
3898 token.id = tokenId;
3899 }
3900 else
3901 {
3902 token.match = prevMatch;
3903 }
3904 switch (i)
3905 {
3906 case 4:
3907 case 5:
3908 case 9:
3909 case 10:
3910 case 11:
3911 case 12:
3912 case 16:
3913 case 18:
3914 case 19:
3915 case 20:
3916 case 21:
3917 case 22:
3918 case 23:
3919 case 24:
3920 case 25:
3921 case 26:
3922 case 30:
3923 case 31:
3924 case 32:
3925 case 33:
3926 case 34:
3927 case 35:
3928 case 36:
3929 {
3930 return 119;
3931 }
3932 default:
3933 {
3934 return -1;
3935 }
3936 }
3937 }
3938 case 3:
3939 {
3940 Lexeme prevMatch = token.match;
3941 token.match = lexeme;
3942 int tokenId = GetTokenId(23);
3943 if (tokenId == CONTINUE_TOKEN)
3944 {
3945 token.id = tokenId;
3946 return -1;
3947 }
3948 else if (tokenId != INVALID_TOKEN)
3949 {
3950 token.id = tokenId;
3951 }
3952 else
3953 {
3954 token.match = prevMatch;
3955 }
3956 return -1;
3957 }
3958 case 2:
3959 {
3960 Lexeme prevMatch = token.match;
3961 token.match = lexeme;
3962 int tokenId = GetTokenId(24);
3963 if (tokenId == CONTINUE_TOKEN)
3964 {
3965 token.id = tokenId;
3966 return -1;
3967 }
3968 else if (tokenId != INVALID_TOKEN)
3969 {
3970 token.id = tokenId;
3971 }
3972 else
3973 {
3974 token.match = prevMatch;
3975 }
3976 switch (i)
3977 {
3978 case 2:
3979 {
3980 return 123;
3981 }
3982 case 3:
3983 {
3984 return 124;
3985 }
3986 default:
3987 {
3988 return -1;
3989 }
3990 }
3991 }
3992 case 124:
3993 {
3994 switch (i)
3995 {
3996 case 0:
3997 case 1:
3998 case 2:
3999 case 4:
4000 case 5:
4001 case 6:
4002 case 7:
4003 case 8:
4004 case 9:
4005 case 10:
4006 case 11:
4007 case 12:
4008 case 13:
4009 case 14:
4010 case 15:
4011 case 16:
4012 case 17:
4013 case 18:
4014 case 19:
4015 case 20:
4016 case 21:
4017 case 22:
4018 case 23:
4019 case 24:
4020 case 25:
4021 case 26:
4022 case 27:
4023 case 28:
4024 case 29:
4025 case 30:
4026 case 31:
4027 case 32:
4028 case 33:
4029 case 34:
4030 case 35:
4031 case 36:
4032 case 37:
4033 case 38:
4034 case 39:
4035 case 40:
4036 case 41:
4037 case 42:
4038 case 43:
4039 case 44:
4040 case 45:
4041 case 46:
4042 case 47:
4043 case 48:
4044 case 49:
4045 case 50:
4046 case 51:
4047 case 52:
4048 case 53:
4049 case 54:
4050 case 55:
4051 {
4052 return 125;
4053 }
4054 case 3:
4055 {
4056 return 126;
4057 }
4058 default:
4059 {
4060 return -1;
4061 }
4062 }
4063 }
4064 case 126:
4065 {
4066 switch (i)
4067 {
4068 case 3:
4069 {
4070 return 126;
4071 }
4072 case 0:
4073 case 1:
4074 case 4:
4075 case 5:
4076 case 6:
4077 case 7:
4078 case 8:
4079 case 9:
4080 case 10:
4081 case 11:
4082 case 12:
4083 case 13:
4084 case 14:
4085 case 15:
4086 case 16:
4087 case 17:
4088 case 18:
4089 case 19:
4090 case 20:
4091 case 21:
4092 case 22:
4093 case 23:
4094 case 24:
4095 case 25:
4096 case 26:
4097 case 27:
4098 case 28:
4099 case 29:
4100 case 30:
4101 case 31:
4102 case 32:
4103 case 33:
4104 case 34:
4105 case 35:
4106 case 36:
4107 case 37:
4108 case 38:
4109 case 39:
4110 case 40:
4111 case 41:
4112 case 42:
4113 case 43:
4114 case 44:
4115 case 45:
4116 case 46:
4117 case 47:
4118 case 48:
4119 case 49:
4120 case 50:
4121 case 51:
4122 case 52:
4123 case 53:
4124 case 54:
4125 case 55:
4126 {
4127 return 127;
4128 }
4129 case 2:
4130 {
4131 return 128;
4132 }
4133 default:
4134 {
4135 return -1;
4136 }
4137 }
4138 }
4139 case 128:
4140 {
4141 Lexeme prevMatch = token.match;
4142 token.match = lexeme;
4143 int tokenId = GetTokenId(0);
4144 if (tokenId == CONTINUE_TOKEN)
4145 {
4146 token.id = tokenId;
4147 return -1;
4148 }
4149 else if (tokenId != INVALID_TOKEN)
4150 {
4151 token.id = tokenId;
4152 }
4153 else
4154 {
4155 token.match = prevMatch;
4156 }
4157 switch (i)
4158 {
4159 case 4:
4160 case 5:
4161 case 8:
4162 case 9:
4163 case 10:
4164 case 11:
4165 case 12:
4166 case 13:
4167 case 14:
4168 case 15:
4169 case 16:
4170 case 17:
4171 case 18:
4172 case 19:
4173 case 20:
4174 case 21:
4175 case 22:
4176 case 23:
4177 case 24:
4178 case 25:
4179 case 26:
4180 case 27:
4181 case 28:
4182 case 29:
4183 case 30:
4184 case 31:
4185 case 32:
4186 case 33:
4187 case 34:
4188 case 35:
4189 case 36:
4190 case 37:
4191 case 38:
4192 case 39:
4193 case 40:
4194 case 41:
4195 case 42:
4196 case 43:
4197 case 44:
4198 case 45:
4199 case 46:
4200 case 47:
4201 case 48:
4202 case 49:
4203 case 50:
4204 case 51:
4205 case 52:
4206 case 53:
4207 case 54:
4208 case 55:
4209 {
4210 return 125;
4211 }
4212 case 3:
4213 {
4214 return 126;
4215 }
4216 case 0:
4217 case 1:
4218 case 6:
4219 case 7:
4220 {
4221 return 129;
4222 }
4223 case 2:
4224 {
4225 return 130;
4226 }
4227 default:
4228 {
4229 return -1;
4230 }
4231 }
4232 }
4233 case 130:
4234 {
4235 switch (i)
4236 {
4237 case 0:
4238 case 1:
4239 case 4:
4240 case 5:
4241 case 6:
4242 case 7:
4243 case 8:
4244 case 9:
4245 case 10:
4246 case 11:
4247 case 12:
4248 case 13:
4249 case 14:
4250 case 15:
4251 case 16:
4252 case 17:
4253 case 18:
4254 case 19:
4255 case 20:
4256 case 21:
4257 case 22:
4258 case 23:
4259 case 24:
4260 case 25:
4261 case 26:
4262 case 27:
4263 case 28:
4264 case 29:
4265 case 30:
4266 case 31:
4267 case 32:
4268 case 33:
4269 case 34:
4270 case 35:
4271 case 36:
4272 case 37:
4273 case 38:
4274 case 39:
4275 case 40:
4276 case 41:
4277 case 42:
4278 case 43:
4279 case 44:
4280 case 45:
4281 case 46:
4282 case 47:
4283 case 48:
4284 case 49:
4285 case 50:
4286 case 51:
4287 case 52:
4288 case 53:
4289 case 54:
4290 case 55:
4291 {
4292 return 125;
4293 }
4294 case 2:
4295 {
4296 return 131;
4297 }
4298 case 3:
4299 {
4300 return 132;
4301 }
4302 default:
4303 {
4304 return -1;
4305 }
4306 }
4307 }
4308 case 132:
4309 {
4310 switch (i)
4311 {
4312 case 3:
4313 {
4314 return 126;
4315 }
4316 case 0:
4317 case 1:
4318 case 4:
4319 case 5:
4320 case 6:
4321 case 7:
4322 case 8:
4323 case 9:
4324 case 10:
4325 case 11:
4326 case 12:
4327 case 13:
4328 case 14:
4329 case 15:
4330 case 16:
4331 case 17:
4332 case 18:
4333 case 19:
4334 case 20:
4335 case 21:
4336 case 22:
4337 case 23:
4338 case 24:
4339 case 25:
4340 case 26:
4341 case 27:
4342 case 28:
4343 case 29:
4344 case 30:
4345 case 31:
4346 case 32:
4347 case 33:
4348 case 34:
4349 case 35:
4350 case 36:
4351 case 37:
4352 case 38:
4353 case 39:
4354 case 40:
4355 case 41:
4356 case 42:
4357 case 43:
4358 case 44:
4359 case 45:
4360 case 46:
4361 case 47:
4362 case 48:
4363 case 49:
4364 case 50:
4365 case 51:
4366 case 52:
4367 case 53:
4368 case 54:
4369 case 55:
4370 {
4371 return 127;
4372 }
4373 case 2:
4374 {
4375 return 128;
4376 }
4377 default:
4378 {
4379 return -1;
4380 }
4381 }
4382 }
4383 case 131:
4384 {
4385 switch (i)
4386 {
4387 case 0:
4388 {
4389 return 133;
4390 }
4391 case 1:
4392 {
4393 return 134;
4394 }
4395 case 2:
4396 case 4:
4397 case 5:
4398 case 6:
4399 case 7:
4400 case 8:
4401 case 9:
4402 case 10:
4403 case 11:
4404 case 12:
4405 case 13:
4406 case 14:
4407 case 15:
4408 case 16:
4409 case 17:
4410 case 18:
4411 case 19:
4412 case 20:
4413 case 21:
4414 case 22:
4415 case 23:
4416 case 24:
4417 case 25:
4418 case 26:
4419 case 27:
4420 case 28:
4421 case 29:
4422 case 30:
4423 case 31:
4424 case 32:
4425 case 33:
4426 case 34:
4427 case 35:
4428 case 36:
4429 case 37:
4430 case 38:
4431 case 39:
4432 case 40:
4433 case 41:
4434 case 42:
4435 case 43:
4436 case 44:
4437 case 45:
4438 case 46:
4439 case 47:
4440 case 48:
4441 case 49:
4442 case 50:
4443 case 51:
4444 case 52:
4445 case 53:
4446 case 54:
4447 case 55:
4448 {
4449 return 135;
4450 }
4451 case 3:
4452 {
4453 return 136;
4454 }
4455 default:
4456 {
4457 return -1;
4458 }
4459 }
4460 }
4461 case 136:
4462 {
4463 switch (i)
4464 {
4465 case 3:
4466 {
4467 return 136;
4468 }
4469 case 0:
4470 {
4471 return 137;
4472 }
4473 case 1:
4474 {
4475 return 138;
4476 }
4477 case 2:
4478 {
4479 return 139;
4480 }
4481 case 4:
4482 case 5:
4483 case 6:
4484 case 7:
4485 case 8:
4486 case 9:
4487 case 10:
4488 case 11:
4489 case 12:
4490 case 13:
4491 case 14:
4492 case 15:
4493 case 16:
4494 case 17:
4495 case 18:
4496 case 19:
4497 case 20:
4498 case 21:
4499 case 22:
4500 case 23:
4501 case 24:
4502 case 25:
4503 case 26:
4504 case 27:
4505 case 28:
4506 case 29:
4507 case 30:
4508 case 31:
4509 case 32:
4510 case 33:
4511 case 34:
4512 case 35:
4513 case 36:
4514 case 37:
4515 case 38:
4516 case 39:
4517 case 40:
4518 case 41:
4519 case 42:
4520 case 43:
4521 case 44:
4522 case 45:
4523 case 46:
4524 case 47:
4525 case 48:
4526 case 49:
4527 case 50:
4528 case 51:
4529 case 52:
4530 case 53:
4531 case 54:
4532 case 55:
4533 {
4534 return 140;
4535 }
4536 default:
4537 {
4538 return -1;
4539 }
4540 }
4541 }
4542 case 140:
4543 {
4544 switch (i)
4545 {
4546 case 0:
4547 {
4548 return 133;
4549 }
4550 case 1:
4551 {
4552 return 134;
4553 }
4554 case 2:
4555 case 4:
4556 case 5:
4557 case 6:
4558 case 7:
4559 case 8:
4560 case 9:
4561 case 10:
4562 case 11:
4563 case 12:
4564 case 13:
4565 case 14:
4566 case 15:
4567 case 16:
4568 case 17:
4569 case 18:
4570 case 19:
4571 case 20:
4572 case 21:
4573 case 22:
4574 case 23:
4575 case 24:
4576 case 25:
4577 case 26:
4578 case 27:
4579 case 28:
4580 case 29:
4581 case 30:
4582 case 31:
4583 case 32:
4584 case 33:
4585 case 34:
4586 case 35:
4587 case 36:
4588 case 37:
4589 case 38:
4590 case 39:
4591 case 40:
4592 case 41:
4593 case 42:
4594 case 43:
4595 case 44:
4596 case 45:
4597 case 46:
4598 case 47:
4599 case 48:
4600 case 49:
4601 case 50:
4602 case 51:
4603 case 52:
4604 case 53:
4605 case 54:
4606 case 55:
4607 {
4608 return 135;
4609 }
4610 case 3:
4611 {
4612 return 136;
4613 }
4614 default:
4615 {
4616 return -1;
4617 }
4618 }
4619 }
4620 case 139:
4621 {
4622 Lexeme prevMatch = token.match;
4623 token.match = lexeme;
4624 int tokenId = GetTokenId(0);
4625 if (tokenId == CONTINUE_TOKEN)
4626 {
4627 token.id = tokenId;
4628 return -1;
4629 }
4630 else if (tokenId != INVALID_TOKEN)
4631 {
4632 token.id = tokenId;
4633 }
4634 else
4635 {
4636 token.match = prevMatch;
4637 }
4638 switch (i)
4639 {
4640 case 4:
4641 case 5:
4642 case 8:
4643 case 9:
4644 case 10:
4645 case 11:
4646 case 12:
4647 case 13:
4648 case 14:
4649 case 15:
4650 case 16:
4651 case 17:
4652 case 18:
4653 case 19:
4654 case 20:
4655 case 21:
4656 case 22:
4657 case 23:
4658 case 24:
4659 case 25:
4660 case 26:
4661 case 27:
4662 case 28:
4663 case 29:
4664 case 30:
4665 case 31:
4666 case 32:
4667 case 33:
4668 case 34:
4669 case 35:
4670 case 36:
4671 case 37:
4672 case 38:
4673 case 39:
4674 case 40:
4675 case 41:
4676 case 42:
4677 case 43:
4678 case 44:
4679 case 45:
4680 case 46:
4681 case 47:
4682 case 48:
4683 case 49:
4684 case 50:
4685 case 51:
4686 case 52:
4687 case 53:
4688 case 54:
4689 case 55:
4690 {
4691 return 135;
4692 }
4693 case 3:
4694 {
4695 return 136;
4696 }
4697 case 0:
4698 {
4699 return 141;
4700 }
4701 case 1:
4702 {
4703 return 142;
4704 }
4705 case 2:
4706 {
4707 return 143;
4708 }
4709 case 6:
4710 case 7:
4711 {
4712 return 144;
4713 }
4714 default:
4715 {
4716 return -1;
4717 }
4718 }
4719 }
4720 case 144:
4721 {
4722 Lexeme prevMatch = token.match;
4723 token.match = lexeme;
4724 int tokenId = GetTokenId(0);
4725 if (tokenId == CONTINUE_TOKEN)
4726 {
4727 token.id = tokenId;
4728 return -1;
4729 }
4730 else if (tokenId != INVALID_TOKEN)
4731 {
4732 token.id = tokenId;
4733 }
4734 else
4735 {
4736 token.match = prevMatch;
4737 }
4738 switch (i)
4739 {
4740 case 4:
4741 case 5:
4742 case 8:
4743 case 9:
4744 case 10:
4745 case 11:
4746 case 12:
4747 case 13:
4748 case 14:
4749 case 15:
4750 case 16:
4751 case 17:
4752 case 18:
4753 case 19:
4754 case 20:
4755 case 21:
4756 case 22:
4757 case 23:
4758 case 24:
4759 case 25:
4760 case 26:
4761 case 27:
4762 case 28:
4763 case 29:
4764 case 30:
4765 case 31:
4766 case 32:
4767 case 33:
4768 case 34:
4769 case 35:
4770 case 36:
4771 case 37:
4772 case 38:
4773 case 39:
4774 case 40:
4775 case 41:
4776 case 42:
4777 case 43:
4778 case 44:
4779 case 45:
4780 case 46:
4781 case 47:
4782 case 48:
4783 case 49:
4784 case 50:
4785 case 51:
4786 case 52:
4787 case 53:
4788 case 54:
4789 case 55:
4790 {
4791 return 135;
4792 }
4793 case 3:
4794 {
4795 return 136;
4796 }
4797 case 0:
4798 {
4799 return 141;
4800 }
4801 case 1:
4802 {
4803 return 142;
4804 }
4805 case 2:
4806 {
4807 return 143;
4808 }
4809 case 6:
4810 case 7:
4811 {
4812 return 144;
4813 }
4814 default:
4815 {
4816 return -1;
4817 }
4818 }
4819 }
4820 case 143:
4821 {
4822 switch (i)
4823 {
4824 case 2:
4825 {
4826 return 131;
4827 }
4828 case 0:
4829 {
4830 return 133;
4831 }
4832 case 1:
4833 {
4834 return 134;
4835 }
4836 case 4:
4837 case 5:
4838 case 6:
4839 case 7:
4840 case 8:
4841 case 9:
4842 case 10:
4843 case 11:
4844 case 12:
4845 case 13:
4846 case 14:
4847 case 15:
4848 case 16:
4849 case 17:
4850 case 18:
4851 case 19:
4852 case 20:
4853 case 21:
4854 case 22:
4855 case 23:
4856 case 24:
4857 case 25:
4858 case 26:
4859 case 27:
4860 case 28:
4861 case 29:
4862 case 30:
4863 case 31:
4864 case 32:
4865 case 33:
4866 case 34:
4867 case 35:
4868 case 36:
4869 case 37:
4870 case 38:
4871 case 39:
4872 case 40:
4873 case 41:
4874 case 42:
4875 case 43:
4876 case 44:
4877 case 45:
4878 case 46:
4879 case 47:
4880 case 48:
4881 case 49:
4882 case 50:
4883 case 51:
4884 case 52:
4885 case 53:
4886 case 54:
4887 case 55:
4888 {
4889 return 135;
4890 }
4891 case 3:
4892 {
4893 return 145;
4894 }
4895 default:
4896 {
4897 return -1;
4898 }
4899 }
4900 }
4901 case 145:
4902 {
4903 switch (i)
4904 {
4905 case 3:
4906 {
4907 return 136;
4908 }
4909 case 0:
4910 {
4911 return 137;
4912 }
4913 case 1:
4914 {
4915 return 138;
4916 }
4917 case 2:
4918 {
4919 return 139;
4920 }
4921 case 4:
4922 case 5:
4923 case 6:
4924 case 7:
4925 case 8:
4926 case 9:
4927 case 10:
4928 case 11:
4929 case 12:
4930 case 13:
4931 case 14:
4932 case 15:
4933 case 16:
4934 case 17:
4935 case 18:
4936 case 19:
4937 case 20:
4938 case 21:
4939 case 22:
4940 case 23:
4941 case 24:
4942 case 25:
4943 case 26:
4944 case 27:
4945 case 28:
4946 case 29:
4947 case 30:
4948 case 31:
4949 case 32:
4950 case 33:
4951 case 34:
4952 case 35:
4953 case 36:
4954 case 37:
4955 case 38:
4956 case 39:
4957 case 40:
4958 case 41:
4959 case 42:
4960 case 43:
4961 case 44:
4962 case 45:
4963 case 46:
4964 case 47:
4965 case 48:
4966 case 49:
4967 case 50:
4968 case 51:
4969 case 52:
4970 case 53:
4971 case 54:
4972 case 55:
4973 {
4974 return 140;
4975 }
4976 default:
4977 {
4978 return -1;
4979 }
4980 }
4981 }
4982 case 142:
4983 {
4984 Lexeme prevMatch = token.match;
4985 token.match = lexeme;
4986 int tokenId = GetTokenId(0);
4987 if (tokenId == CONTINUE_TOKEN)
4988 {
4989 token.id = tokenId;
4990 return -1;
4991 }
4992 else if (tokenId != INVALID_TOKEN)
4993 {
4994 token.id = tokenId;
4995 }
4996 else
4997 {
4998 token.match = prevMatch;
4999 }
5000 switch (i)
5001 {
5002 case 4:
5003 case 5:
5004 case 8:
5005 case 9:
5006 case 10:
5007 case 11:
5008 case 12:
5009 case 13:
5010 case 14:
5011 case 15:
5012 case 16:
5013 case 17:
5014 case 18:
5015 case 19:
5016 case 20:
5017 case 21:
5018 case 22:
5019 case 23:
5020 case 24:
5021 case 25:
5022 case 26:
5023 case 27:
5024 case 28:
5025 case 29:
5026 case 30:
5027 case 31:
5028 case 32:
5029 case 33:
5030 case 34:
5031 case 35:
5032 case 36:
5033 case 37:
5034 case 38:
5035 case 39:
5036 case 40:
5037 case 41:
5038 case 42:
5039 case 43:
5040 case 44:
5041 case 45:
5042 case 46:
5043 case 47:
5044 case 48:
5045 case 49:
5046 case 50:
5047 case 51:
5048 case 52:
5049 case 53:
5050 case 54:
5051 case 55:
5052 {
5053 return 125;
5054 }
5055 case 3:
5056 {
5057 return 126;
5058 }
5059 case 1:
5060 case 6:
5061 case 7:
5062 {
5063 return 129;
5064 }
5065 case 2:
5066 {
5067 return 130;
5068 }
5069 case 0:
5070 {
5071 return 146;
5072 }
5073 default:
5074 {
5075 return -1;
5076 }
5077 }
5078 }
5079 case 146:
5080 {
5081 Lexeme prevMatch = token.match;
5082 token.match = lexeme;
5083 int tokenId = GetTokenId(0);
5084 if (tokenId == CONTINUE_TOKEN)
5085 {
5086 token.id = tokenId;
5087 return -1;
5088 }
5089 else if (tokenId != INVALID_TOKEN)
5090 {
5091 token.id = tokenId;
5092 }
5093 else
5094 {
5095 token.match = prevMatch;
5096 }
5097 switch (i)
5098 {
5099 case 4:
5100 case 5:
5101 case 8:
5102 case 9:
5103 case 10:
5104 case 11:
5105 case 12:
5106 case 13:
5107 case 14:
5108 case 15:
5109 case 16:
5110 case 17:
5111 case 18:
5112 case 19:
5113 case 20:
5114 case 21:
5115 case 22:
5116 case 23:
5117 case 24:
5118 case 25:
5119 case 26:
5120 case 27:
5121 case 28:
5122 case 29:
5123 case 30:
5124 case 31:
5125 case 32:
5126 case 33:
5127 case 34:
5128 case 35:
5129 case 36:
5130 case 37:
5131 case 38:
5132 case 39:
5133 case 40:
5134 case 41:
5135 case 42:
5136 case 43:
5137 case 44:
5138 case 45:
5139 case 46:
5140 case 47:
5141 case 48:
5142 case 49:
5143 case 50:
5144 case 51:
5145 case 52:
5146 case 53:
5147 case 54:
5148 case 55:
5149 {
5150 return 125;
5151 }
5152 case 3:
5153 {
5154 return 126;
5155 }
5156 case 0:
5157 case 1:
5158 case 6:
5159 case 7:
5160 {
5161 return 129;
5162 }
5163 case 2:
5164 {
5165 return 130;
5166 }
5167 default:
5168 {
5169 return -1;
5170 }
5171 }
5172 }
5173 case 141:
5174 {
5175 Lexeme prevMatch = token.match;
5176 token.match = lexeme;
5177 int tokenId = GetTokenId(0);
5178 if (tokenId == CONTINUE_TOKEN)
5179 {
5180 token.id = tokenId;
5181 return -1;
5182 }
5183 else if (tokenId != INVALID_TOKEN)
5184 {
5185 token.id = tokenId;
5186 }
5187 else
5188 {
5189 token.match = prevMatch;
5190 }
5191 switch (i)
5192 {
5193 case 4:
5194 case 5:
5195 case 8:
5196 case 9:
5197 case 10:
5198 case 11:
5199 case 12:
5200 case 13:
5201 case 14:
5202 case 15:
5203 case 16:
5204 case 17:
5205 case 18:
5206 case 19:
5207 case 20:
5208 case 21:
5209 case 22:
5210 case 23:
5211 case 24:
5212 case 25:
5213 case 26:
5214 case 27:
5215 case 28:
5216 case 29:
5217 case 30:
5218 case 31:
5219 case 32:
5220 case 33:
5221 case 34:
5222 case 35:
5223 case 36:
5224 case 37:
5225 case 38:
5226 case 39:
5227 case 40:
5228 case 41:
5229 case 42:
5230 case 43:
5231 case 44:
5232 case 45:
5233 case 46:
5234 case 47:
5235 case 48:
5236 case 49:
5237 case 50:
5238 case 51:
5239 case 52:
5240 case 53:
5241 case 54:
5242 case 55:
5243 {
5244 return 125;
5245 }
5246 case 3:
5247 {
5248 return 126;
5249 }
5250 case 0:
5251 case 1:
5252 case 6:
5253 case 7:
5254 {
5255 return 129;
5256 }
5257 case 2:
5258 {
5259 return 130;
5260 }
5261 default:
5262 {
5263 return -1;
5264 }
5265 }
5266 }
5267 case 138:
5268 {
5269 Lexeme prevMatch = token.match;
5270 token.match = lexeme;
5271 int tokenId = GetTokenId(0);
5272 if (tokenId == CONTINUE_TOKEN)
5273 {
5274 token.id = tokenId;
5275 return -1;
5276 }
5277 else if (tokenId != INVALID_TOKEN)
5278 {
5279 token.id = tokenId;
5280 }
5281 else
5282 {
5283 token.match = prevMatch;
5284 }
5285 switch (i)
5286 {
5287 case 4:
5288 case 5:
5289 case 8:
5290 case 9:
5291 case 10:
5292 case 11:
5293 case 12:
5294 case 13:
5295 case 14:
5296 case 15:
5297 case 16:
5298 case 17:
5299 case 18:
5300 case 19:
5301 case 20:
5302 case 21:
5303 case 22:
5304 case 23:
5305 case 24:
5306 case 25:
5307 case 26:
5308 case 27:
5309 case 28:
5310 case 29:
5311 case 30:
5312 case 31:
5313 case 32:
5314 case 33:
5315 case 34:
5316 case 35:
5317 case 36:
5318 case 37:
5319 case 38:
5320 case 39:
5321 case 40:
5322 case 41:
5323 case 42:
5324 case 43:
5325 case 44:
5326 case 45:
5327 case 46:
5328 case 47:
5329 case 48:
5330 case 49:
5331 case 50:
5332 case 51:
5333 case 52:
5334 case 53:
5335 case 54:
5336 case 55:
5337 {
5338 return 125;
5339 }
5340 case 3:
5341 {
5342 return 126;
5343 }
5344 case 1:
5345 case 6:
5346 case 7:
5347 {
5348 return 129;
5349 }
5350 case 2:
5351 {
5352 return 130;
5353 }
5354 case 0:
5355 {
5356 return 146;
5357 }
5358 default:
5359 {
5360 return -1;
5361 }
5362 }
5363 }
5364 case 137:
5365 {
5366 Lexeme prevMatch = token.match;
5367 token.match = lexeme;
5368 int tokenId = GetTokenId(0);
5369 if (tokenId == CONTINUE_TOKEN)
5370 {
5371 token.id = tokenId;
5372 return -1;
5373 }
5374 else if (tokenId != INVALID_TOKEN)
5375 {
5376 token.id = tokenId;
5377 }
5378 else
5379 {
5380 token.match = prevMatch;
5381 }
5382 switch (i)
5383 {
5384 case 4:
5385 case 5:
5386 case 8:
5387 case 9:
5388 case 10:
5389 case 11:
5390 case 12:
5391 case 13:
5392 case 14:
5393 case 15:
5394 case 16:
5395 case 17:
5396 case 18:
5397 case 19:
5398 case 20:
5399 case 21:
5400 case 22:
5401 case 23:
5402 case 24:
5403 case 25:
5404 case 26:
5405 case 27:
5406 case 28:
5407 case 29:
5408 case 30:
5409 case 31:
5410 case 32:
5411 case 33:
5412 case 34:
5413 case 35:
5414 case 36:
5415 case 37:
5416 case 38:
5417 case 39:
5418 case 40:
5419 case 41:
5420 case 42:
5421 case 43:
5422 case 44:
5423 case 45:
5424 case 46:
5425 case 47:
5426 case 48:
5427 case 49:
5428 case 50:
5429 case 51:
5430 case 52:
5431 case 53:
5432 case 54:
5433 case 55:
5434 {
5435 return 125;
5436 }
5437 case 3:
5438 {
5439 return 126;
5440 }
5441 case 0:
5442 case 1:
5443 case 6:
5444 case 7:
5445 {
5446 return 129;
5447 }
5448 case 2:
5449 {
5450 return 130;
5451 }
5452 default:
5453 {
5454 return -1;
5455 }
5456 }
5457 }
5458 case 135:
5459 {
5460 switch (i)
5461 {
5462 case 0:
5463 {
5464 return 133;
5465 }
5466 case 1:
5467 {
5468 return 134;
5469 }
5470 case 2:
5471 case 4:
5472 case 5:
5473 case 6:
5474 case 7:
5475 case 8:
5476 case 9:
5477 case 10:
5478 case 11:
5479 case 12:
5480 case 13:
5481 case 14:
5482 case 15:
5483 case 16:
5484 case 17:
5485 case 18:
5486 case 19:
5487 case 20:
5488 case 21:
5489 case 22:
5490 case 23:
5491 case 24:
5492 case 25:
5493 case 26:
5494 case 27:
5495 case 28:
5496 case 29:
5497 case 30:
5498 case 31:
5499 case 32:
5500 case 33:
5501 case 34:
5502 case 35:
5503 case 36:
5504 case 37:
5505 case 38:
5506 case 39:
5507 case 40:
5508 case 41:
5509 case 42:
5510 case 43:
5511 case 44:
5512 case 45:
5513 case 46:
5514 case 47:
5515 case 48:
5516 case 49:
5517 case 50:
5518 case 51:
5519 case 52:
5520 case 53:
5521 case 54:
5522 case 55:
5523 {
5524 return 135;
5525 }
5526 case 3:
5527 {
5528 return 136;
5529 }
5530 default:
5531 {
5532 return -1;
5533 }
5534 }
5535 }
5536 case 134:
5537 {
5538 Lexeme prevMatch = token.match;
5539 token.match = lexeme;
5540 int tokenId = GetTokenId(0);
5541 if (tokenId == CONTINUE_TOKEN)
5542 {
5543 token.id = tokenId;
5544 return -1;
5545 }
5546 else if (tokenId != INVALID_TOKEN)
5547 {
5548 token.id = tokenId;
5549 }
5550 else
5551 {
5552 token.match = prevMatch;
5553 }
5554 switch (i)
5555 {
5556 case 4:
5557 case 5:
5558 case 8:
5559 case 9:
5560 case 10:
5561 case 11:
5562 case 12:
5563 case 13:
5564 case 14:
5565 case 15:
5566 case 16:
5567 case 17:
5568 case 18:
5569 case 19:
5570 case 20:
5571 case 21:
5572 case 22:
5573 case 23:
5574 case 24:
5575 case 25:
5576 case 26:
5577 case 27:
5578 case 28:
5579 case 29:
5580 case 30:
5581 case 31:
5582 case 32:
5583 case 33:
5584 case 34:
5585 case 35:
5586 case 36:
5587 case 37:
5588 case 38:
5589 case 39:
5590 case 40:
5591 case 41:
5592 case 42:
5593 case 43:
5594 case 44:
5595 case 45:
5596 case 46:
5597 case 47:
5598 case 48:
5599 case 49:
5600 case 50:
5601 case 51:
5602 case 52:
5603 case 53:
5604 case 54:
5605 case 55:
5606 {
5607 return 125;
5608 }
5609 case 3:
5610 {
5611 return 126;
5612 }
5613 case 1:
5614 case 6:
5615 case 7:
5616 {
5617 return 129;
5618 }
5619 case 2:
5620 {
5621 return 130;
5622 }
5623 case 0:
5624 {
5625 return 146;
5626 }
5627 default:
5628 {
5629 return -1;
5630 }
5631 }
5632 }
5633 case 133:
5634 {
5635 Lexeme prevMatch = token.match;
5636 token.match = lexeme;
5637 int tokenId = GetTokenId(0);
5638 if (tokenId == CONTINUE_TOKEN)
5639 {
5640 token.id = tokenId;
5641 return -1;
5642 }
5643 else if (tokenId != INVALID_TOKEN)
5644 {
5645 token.id = tokenId;
5646 }
5647 else
5648 {
5649 token.match = prevMatch;
5650 }
5651 switch (i)
5652 {
5653 case 4:
5654 case 5:
5655 case 8:
5656 case 9:
5657 case 10:
5658 case 11:
5659 case 12:
5660 case 13:
5661 case 14:
5662 case 15:
5663 case 16:
5664 case 17:
5665 case 18:
5666 case 19:
5667 case 20:
5668 case 21:
5669 case 22:
5670 case 23:
5671 case 24:
5672 case 25:
5673 case 26:
5674 case 27:
5675 case 28:
5676 case 29:
5677 case 30:
5678 case 31:
5679 case 32:
5680 case 33:
5681 case 34:
5682 case 35:
5683 case 36:
5684 case 37:
5685 case 38:
5686 case 39:
5687 case 40:
5688 case 41:
5689 case 42:
5690 case 43:
5691 case 44:
5692 case 45:
5693 case 46:
5694 case 47:
5695 case 48:
5696 case 49:
5697 case 50:
5698 case 51:
5699 case 52:
5700 case 53:
5701 case 54:
5702 case 55:
5703 {
5704 return 125;
5705 }
5706 case 3:
5707 {
5708 return 126;
5709 }
5710 case 0:
5711 case 1:
5712 case 6:
5713 case 7:
5714 {
5715 return 129;
5716 }
5717 case 2:
5718 {
5719 return 130;
5720 }
5721 default:
5722 {
5723 return -1;
5724 }
5725 }
5726 }
5727 case 129:
5728 {
5729 Lexeme prevMatch = token.match;
5730 token.match = lexeme;
5731 int tokenId = GetTokenId(0);
5732 if (tokenId == CONTINUE_TOKEN)
5733 {
5734 token.id = tokenId;
5735 return -1;
5736 }
5737 else if (tokenId != INVALID_TOKEN)
5738 {
5739 token.id = tokenId;
5740 }
5741 else
5742 {
5743 token.match = prevMatch;
5744 }
5745 switch (i)
5746 {
5747 case 4:
5748 case 5:
5749 case 8:
5750 case 9:
5751 case 10:
5752 case 11:
5753 case 12:
5754 case 13:
5755 case 14:
5756 case 15:
5757 case 16:
5758 case 17:
5759 case 18:
5760 case 19:
5761 case 20:
5762 case 21:
5763 case 22:
5764 case 23:
5765 case 24:
5766 case 25:
5767 case 26:
5768 case 27:
5769 case 28:
5770 case 29:
5771 case 30:
5772 case 31:
5773 case 32:
5774 case 33:
5775 case 34:
5776 case 35:
5777 case 36:
5778 case 37:
5779 case 38:
5780 case 39:
5781 case 40:
5782 case 41:
5783 case 42:
5784 case 43:
5785 case 44:
5786 case 45:
5787 case 46:
5788 case 47:
5789 case 48:
5790 case 49:
5791 case 50:
5792 case 51:
5793 case 52:
5794 case 53:
5795 case 54:
5796 case 55:
5797 {
5798 return 125;
5799 }
5800 case 3:
5801 {
5802 return 126;
5803 }
5804 case 0:
5805 case 1:
5806 case 6:
5807 case 7:
5808 {
5809 return 129;
5810 }
5811 case 2:
5812 {
5813 return 130;
5814 }
5815 default:
5816 {
5817 return -1;
5818 }
5819 }
5820 }
5821 case 127:
5822 {
5823 switch (i)
5824 {
5825 case 0:
5826 case 1:
5827 case 2:
5828 case 4:
5829 case 5:
5830 case 6:
5831 case 7:
5832 case 8:
5833 case 9:
5834 case 10:
5835 case 11:
5836 case 12:
5837 case 13:
5838 case 14:
5839 case 15:
5840 case 16:
5841 case 17:
5842 case 18:
5843 case 19:
5844 case 20:
5845 case 21:
5846 case 22:
5847 case 23:
5848 case 24:
5849 case 25:
5850 case 26:
5851 case 27:
5852 case 28:
5853 case 29:
5854 case 30:
5855 case 31:
5856 case 32:
5857 case 33:
5858 case 34:
5859 case 35:
5860 case 36:
5861 case 37:
5862 case 38:
5863 case 39:
5864 case 40:
5865 case 41:
5866 case 42:
5867 case 43:
5868 case 44:
5869 case 45:
5870 case 46:
5871 case 47:
5872 case 48:
5873 case 49:
5874 case 50:
5875 case 51:
5876 case 52:
5877 case 53:
5878 case 54:
5879 case 55:
5880 {
5881 return 125;
5882 }
5883 case 3:
5884 {
5885 return 126;
5886 }
5887 default:
5888 {
5889 return -1;
5890 }
5891 }
5892 }
5893 case 125:
5894 {
5895 switch (i)
5896 {
5897 case 0:
5898 case 1:
5899 case 2:
5900 case 4:
5901 case 5:
5902 case 6:
5903 case 7:
5904 case 8:
5905 case 9:
5906 case 10:
5907 case 11:
5908 case 12:
5909 case 13:
5910 case 14:
5911 case 15:
5912 case 16:
5913 case 17:
5914 case 18:
5915 case 19:
5916 case 20:
5917 case 21:
5918 case 22:
5919 case 23:
5920 case 24:
5921 case 25:
5922 case 26:
5923 case 27:
5924 case 28:
5925 case 29:
5926 case 30:
5927 case 31:
5928 case 32:
5929 case 33:
5930 case 34:
5931 case 35:
5932 case 36:
5933 case 37:
5934 case 38:
5935 case 39:
5936 case 40:
5937 case 41:
5938 case 42:
5939 case 43:
5940 case 44:
5941 case 45:
5942 case 46:
5943 case 47:
5944 case 48:
5945 case 49:
5946 case 50:
5947 case 51:
5948 case 52:
5949 case 53:
5950 case 54:
5951 case 55:
5952 {
5953 return 125;
5954 }
5955 case 3:
5956 {
5957 return 126;
5958 }
5959 default:
5960 {
5961 return -1;
5962 }
5963 }
5964 }
5965 case 123:
5966 {
5967 switch (i)
5968 {
5969 case 0:
5970 {
5971 return 147;
5972 }
5973 case 1:
5974 {
5975 return 148;
5976 }
5977 case 2:
5978 case 3:
5979 case 4:
5980 case 5:
5981 case 6:
5982 case 7:
5983 case 8:
5984 case 9:
5985 case 10:
5986 case 11:
5987 case 12:
5988 case 13:
5989 case 14:
5990 case 15:
5991 case 16:
5992 case 17:
5993 case 18:
5994 case 19:
5995 case 20:
5996 case 21:
5997 case 22:
5998 case 23:
5999 case 24:
6000 case 25:
6001 case 26:
6002 case 27:
6003 case 28:
6004 case 29:
6005 case 30:
6006 case 31:
6007 case 32:
6008 case 33:
6009 case 34:
6010 case 35:
6011 case 36:
6012 case 37:
6013 case 38:
6014 case 39:
6015 case 40:
6016 case 41:
6017 case 42:
6018 case 43:
6019 case 44:
6020 case 45:
6021 case 46:
6022 case 47:
6023 case 48:
6024 case 49:
6025 case 50:
6026 case 51:
6027 case 52:
6028 case 53:
6029 case 54:
6030 case 55:
6031 {
6032 return 149;
6033 }
6034 default:
6035 {
6036 return -1;
6037 }
6038 }
6039 }
6040 case 149:
6041 {
6042 switch (i)
6043 {
6044 case 0:
6045 {
6046 return 147;
6047 }
6048 case 1:
6049 {
6050 return 148;
6051 }
6052 case 2:
6053 case 3:
6054 case 4:
6055 case 5:
6056 case 6:
6057 case 7:
6058 case 8:
6059 case 9:
6060 case 10:
6061 case 11:
6062 case 12:
6063 case 13:
6064 case 14:
6065 case 15:
6066 case 16:
6067 case 17:
6068 case 18:
6069 case 19:
6070 case 20:
6071 case 21:
6072 case 22:
6073 case 23:
6074 case 24:
6075 case 25:
6076 case 26:
6077 case 27:
6078 case 28:
6079 case 29:
6080 case 30:
6081 case 31:
6082 case 32:
6083 case 33:
6084 case 34:
6085 case 35:
6086 case 36:
6087 case 37:
6088 case 38:
6089 case 39:
6090 case 40:
6091 case 41:
6092 case 42:
6093 case 43:
6094 case 44:
6095 case 45:
6096 case 46:
6097 case 47:
6098 case 48:
6099 case 49:
6100 case 50:
6101 case 51:
6102 case 52:
6103 case 53:
6104 case 54:
6105 case 55:
6106 {
6107 return 149;
6108 }
6109 default:
6110 {
6111 return -1;
6112 }
6113 }
6114 }
6115 case 148:
6116 {
6117 Lexeme prevMatch = token.match;
6118 token.match = lexeme;
6119 int tokenId = GetTokenId(0);
6120 if (tokenId == CONTINUE_TOKEN)
6121 {
6122 token.id = tokenId;
6123 return -1;
6124 }
6125 else if (tokenId != INVALID_TOKEN)
6126 {
6127 token.id = tokenId;
6128 }
6129 else
6130 {
6131 token.match = prevMatch;
6132 }
6133 switch (i)
6134 {
6135 case 1:
6136 case 6:
6137 case 7:
6138 {
6139 return 1;
6140 }
6141 case 0:
6142 {
6143 return 150;
6144 }
6145 case 2:
6146 {
6147 return 151;
6148 }
6149 default:
6150 {
6151 return -1;
6152 }
6153 }
6154 }
6155 case 151:
6156 {
6157 switch (i)
6158 {
6159 case 2:
6160 {
6161 return 123;
6162 }
6163 case 3:
6164 {
6165 return 124;
6166 }
6167 default:
6168 {
6169 return -1;
6170 }
6171 }
6172 }
6173 case 150:
6174 {
6175 Lexeme prevMatch = token.match;
6176 token.match = lexeme;
6177 int tokenId = GetTokenId(0);
6178 if (tokenId == CONTINUE_TOKEN)
6179 {
6180 token.id = tokenId;
6181 return -1;
6182 }
6183 else if (tokenId != INVALID_TOKEN)
6184 {
6185 token.id = tokenId;
6186 }
6187 else
6188 {
6189 token.match = prevMatch;
6190 }
6191 switch (i)
6192 {
6193 case 0:
6194 case 1:
6195 case 6:
6196 case 7:
6197 {
6198 return 1;
6199 }
6200 case 2:
6201 {
6202 return 151;
6203 }
6204 default:
6205 {
6206 return -1;
6207 }
6208 }
6209 }
6210 case 147:
6211 {
6212 Lexeme prevMatch = token.match;
6213 token.match = lexeme;
6214 int tokenId = GetTokenId(0);
6215 if (tokenId == CONTINUE_TOKEN)
6216 {
6217 token.id = tokenId;
6218 return -1;
6219 }
6220 else if (tokenId != INVALID_TOKEN)
6221 {
6222 token.id = tokenId;
6223 }
6224 else
6225 {
6226 token.match = prevMatch;
6227 }
6228 switch (i)
6229 {
6230 case 0:
6231 case 1:
6232 case 6:
6233 case 7:
6234 {
6235 return 1;
6236 }
6237 case 2:
6238 {
6239 return 151;
6240 }
6241 default:
6242 {
6243 return -1;
6244 }
6245 }
6246 }
6247 case 1:
6248 {
6249 Lexeme prevMatch = token.match;
6250 token.match = lexeme;
6251 int tokenId = GetTokenId(0);
6252 if (tokenId == CONTINUE_TOKEN)
6253 {
6254 token.id = tokenId;
6255 return -1;
6256 }
6257 else if (tokenId != INVALID_TOKEN)
6258 {
6259 token.id = tokenId;
6260 }
6261 else
6262 {
6263 token.match = prevMatch;
6264 }
6265 switch (i)
6266 {
6267 case 0:
6268 case 1:
6269 case 6:
6270 case 7:
6271 {
6272 return 1;
6273 }
6274 case 2:
6275 {
6276 return 151;
6277 }
6278 default:
6279 {
6280 return -1;
6281 }
6282 }
6283 }
6284 }
6285 return -1;
6286 }
6287
6288 int CmajorLexer::GetTokenId(int statementIndex)
6289 {
6290 switch (statementIndex)
6291 {
6292 case 0:
6293 {
6294 Retract();
6295 break;
6296 }
6297 case 1:
6298 {
6299 Retract();
6300 int kw = GetKeywordToken(token.match);
6301 if (kw == INVALID_TOKEN) return ID;
6302 else return kw;
6303 break;
6304 }
6305 case 2:
6306 {
6307 Retract();
6308 return INTLIT;
6309 break;
6310 }
6311 case 3:
6312 {
6313 Retract();
6314 return FLOATINGLIT;
6315 break;
6316 }
6317 case 4:
6318 {
6319 Retract();
6320 return CHARLIT;
6321 break;
6322 }
6323 case 5:
6324 {
6325 Retract();
6326 return STRINGLIT;
6327 break;
6328 }
6329 case 6:
6330 {
6331 Retract();
6332 return EQUIVALENCE;
6333 break;
6334 }
6335 case 7:
6336 {
6337 Retract();
6338 return IMPLICATION;
6339 break;
6340 }
6341 case 8:
6342 {
6343 Retract();
6344 return DISJUNCTION;
6345 break;
6346 }
6347 case 9:
6348 {
6349 Retract();
6350 return AMPAMP;
6351 break;
6352 }
6353 case 10:
6354 {
6355 Retract();
6356 return BITOR;
6357 break;
6358 }
6359 case 11:
6360 {
6361 Retract();
6362 return BITXOR;
6363 break;
6364 }
6365 case 12:
6366 {
6367 Retract();
6368 return AMP;
6369 break;
6370 }
6371 case 13:
6372 {
6373 Retract();
6374 return EQ;
6375 break;
6376 }
6377 case 14:
6378 {
6379 Retract();
6380 return NEQ;
6381 break;
6382 }
6383 case 15:
6384 {
6385 Retract();
6386 return LEQ;
6387 break;
6388 }
6389 case 16:
6390 {
6391 Retract();
6392 return GEQ;
6393 break;
6394 }
6395 case 17:
6396 {
6397 Retract();
6398 return LANGLE;
6399 break;
6400 }
6401 case 18:
6402 {
6403 Retract();
6404 return RANGLE;
6405 break;
6406 }
6407 case 19:
6408 {
6409 if (parsingOperatorFunctionGroupId) return INVALID_TOKEN;
6410 Retract();
6411 return SHIFTLEFT;
6412 break;
6413 }
6414 case 20:
6415 {
6416 if (leftAngleCount > 0) return INVALID_TOKEN;
6417 Retract();
6418 return SHIFTRIGHT;
6419 break;
6420 }
6421 case 21:
6422 {
6423 Retract();
6424 return PLUS;
6425 break;
6426 }
6427 case 22:
6428 {
6429 Retract();
6430 return MINUS;
6431 break;
6432 }
6433 case 23:
6434 {
6435 Retract();
6436 return STAR;
6437 break;
6438 }
6439 case 24:
6440 {
6441 Retract();
6442 return DIV;
6443 break;
6444 }
6445 case 25:
6446 {
6447 Retract();
6448 return REM;
6449 break;
6450 }
6451 case 26:
6452 {
6453 Retract();
6454 return PLUSPLUS;
6455 break;
6456 }
6457 case 27:
6458 {
6459 Retract();
6460 return MINUSMINUS;
6461 break;
6462 }
6463 case 28:
6464 {
6465 Retract();
6466 return EXCLAMATION;
6467 break;
6468 }
6469 case 29:
6470 {
6471 Retract();
6472 return CPL;
6473 break;
6474 }
6475 case 30:
6476 {
6477 Retract();
6478 return DOT;
6479 break;
6480 }
6481 case 31:
6482 {
6483 Retract();
6484 return ARROW;
6485 break;
6486 }
6487 case 32:
6488 {
6489 Retract();
6490 return LBRACKET;
6491 break;
6492 }
6493 case 33:
6494 {
6495 Retract();
6496 return RBRACKET;
6497 break;
6498 }
6499 case 34:
6500 {
6501 Retract();
6502 return LPAREN;
6503 break;
6504 }
6505 case 35:
6506 {
6507 Retract();
6508 return RPAREN;
6509 break;
6510 }
6511 case 36:
6512 {
6513 Retract();
6514 return LBRACE;
6515 break;
6516 }
6517 case 37:
6518 {
6519 Retract();
6520 return RBRACE;
6521 break;
6522 }
6523 case 38:
6524 {
6525 Retract();
6526 return COMMA;
6527 break;
6528 }
6529 case 39:
6530 {
6531 Retract();
6532 return ASSIGN;
6533 break;
6534 }
6535 case 40:
6536 {
6537 Retract();
6538 return COLON;
6539 break;
6540 }
6541 case 41:
6542 {
6543 Retract();
6544 return SEMICOLON;
6545 break;
6546 }
6547 case 42:
6548 {
6549 Retract();
6550 return HASH;
6551 break;
6552 }
6553 }
6554 return CONTINUE_TOKEN;
6555 }