1
2
3
4 #include <sngcpp/lexer/CppTokenLexer.hpp>
5 #include <sngcpp/lexer/CppTokenLexerKeywords.hpp>
6 #include <soulng/lexer/Token.hpp>
7 #include <sngcpp/lexer/CppTokenLexerTokens.hpp>
8 #include <sngcpp/lexer/CppTokenLexerClassMap.hpp>
9
10 using namespace soulng::lexer;
11 using namespace CppTokenLexerTokens;
12
13 CppTokenLexer::CppTokenLexer(const std::u32string& content_, const std::string& fileName_, int fileIndex_) : soulng::lexer::Lexer(content_, fileName_, fileIndex_),
14 inBlockComment(), writer()
15 {
16 SetKeywordMap(CppTokenLexerKeywords::GetKeywordMap());
17 }
18
19 CppTokenLexer::CppTokenLexer(const char32_t* start_, const char32_t* end_, const std::string& fileName_, int fileIndex_) : soulng::lexer::Lexer(start_, end_, fileName_, fileIndex_),
20 inBlockComment(), writer()
21 {
22 SetKeywordMap(CppTokenLexerKeywords::GetKeywordMap());
23 }
24
25 int CppTokenLexer::NextState(int state, char32_t c)
26 {
27 int i = CppTokenLexerClassMap::GetClass(c);
28 switch (state)
29 {
30 case 0:
31 {
32 switch (i)
33 {
34 case 0:
35 {
36 return 1;
37 }
38 case 1:
39 {
40 return 2;
41 }
42 case 2:
43 {
44 return 3;
45 }
46 case 3:
47 {
48 return 4;
49 }
50 case 4:
51 {
52 return 5;
53 }
54 case 5:
55 case 14:
56 case 18:
57 case 19:
58 case 20:
59 case 21:
60 case 22:
61 case 24:
62 case 28:
63 case 29:
64 case 30:
65 case 31:
66 case 32:
67 case 33:
68 {
69 return 6;
70 }
71 case 6:
72 case 7:
73 case 8:
74 {
75 return 7;
76 }
77 case 9:
78 {
79 return 8;
80 }
81 case 10:
82 {
83 return 9;
84 }
85 case 11:
86 {
87 return 10;
88 }
89 case 12:
90 {
91 return 11;
92 }
93 case 13:
94 {
95 return 12;
96 }
97 case 15:
98 {
99 return 13;
100 }
101 case 16:
102 {
103 return 14;
104 }
105 case 17:
106 {
107 return 15;
108 }
109 case 23:
110 {
111 return 16;
112 }
113 case 25:
114 case 26:
115 case 27:
116 {
117 return 17;
118 }
119 case 34:
120 case 35:
121 {
122 return 18;
123 }
124 case 36:
125 {
126 return 19;
127 }
128 case 37:
129 {
130 return 20;
131 }
132 case 38:
133 {
134 return 21;
135 }
136 case 39:
137 {
138 return 22;
139 }
140 case 40:
141 {
142 return 23;
143 }
144 case 41:
145 {
146 return 24;
147 }
148 case 42:
149 {
150 return 25;
151 }
152 case 43:
153 {
154 return 26;
155 }
156 case 44:
157 {
158 return 27;
159 }
160 case 45:
161 {
162 return 28;
163 }
164 case 46:
165 {
166 return 29;
167 }
168 case 47:
169 {
170 return 30;
171 }
172 case 48:
173 {
174 return 31;
175 }
176 case 49:
177 {
178 return 32;
179 }
180 case 50:
181 {
182 return 33;
183 }
184 case 51:
185 {
186 return 34;
187 }
188 case 52:
189 {
190 return 35;
191 }
192 case 53:
193 {
194 return 36;
195 }
196 case 54:
197 {
198 return 37;
199 }
200 case 55:
201 {
202 return 38;
203 }
204 default:
205 {
206 return -1;
207 }
208 }
209 }
210 case 38:
211 {
212 Lexeme prevMatch = token.match;
213 token.match = lexeme;
214 int tokenId = GetTokenId(59);
215 if (tokenId == CONTINUE_TOKEN)
216 {
217 token.id = tokenId;
218 return -1;
219 }
220 else if (tokenId != INVALID_TOKEN)
221 {
222 token.id = tokenId;
223 }
224 else
225 {
226 token.match = prevMatch;
227 }
228 switch (i)
229 {
230 case 2:
231 case 3:
232 case 5:
233 case 6:
234 case 7:
235 case 8:
236 case 9:
237 case 10:
238 case 11:
239 case 12:
240 case 13:
241 case 14:
242 case 15:
243 case 16:
244 case 17:
245 case 18:
246 case 19:
247 case 20:
248 case 21:
249 case 22:
250 case 23:
251 case 24:
252 case 25:
253 case 26:
254 case 27:
255 case 28:
256 case 29:
257 case 30:
258 case 31:
259 case 32:
260 case 33:
261 case 34:
262 case 35:
263 case 36:
264 case 37:
265 case 38:
266 case 39:
267 case 40:
268 case 41:
269 case 42:
270 case 43:
271 case 44:
272 case 45:
273 case 46:
274 case 47:
275 case 48:
276 case 49:
277 case 50:
278 case 51:
279 case 52:
280 case 53:
281 case 54:
282 case 55:
283 {
284 return 7;
285 }
286 case 0:
287 {
288 return 39;
289 }
290 case 1:
291 {
292 return 40;
293 }
294 case 4:
295 {
296 return 41;
297 }
298 default:
299 {
300 return -1;
301 }
302 }
303 }
304 case 41:
305 {
306 switch (i)
307 {
308 case 0:
309 {
310 return 39;
311 }
312 case 1:
313 {
314 return 40;
315 }
316 case 4:
317 {
318 return 41;
319 }
320 case 2:
321 case 5:
322 case 6:
323 case 7:
324 case 8:
325 case 9:
326 case 10:
327 case 11:
328 case 12:
329 case 13:
330 case 14:
331 case 15:
332 case 16:
333 case 17:
334 case 18:
335 case 19:
336 case 20:
337 case 21:
338 case 22:
339 case 23:
340 case 24:
341 case 25:
342 case 26:
343 case 27:
344 case 28:
345 case 29:
346 case 30:
347 case 31:
348 case 32:
349 case 33:
350 case 34:
351 case 35:
352 case 36:
353 case 37:
354 case 38:
355 case 39:
356 case 40:
357 case 41:
358 case 42:
359 case 43:
360 case 44:
361 case 45:
362 case 46:
363 case 47:
364 case 48:
365 case 49:
366 case 50:
367 case 51:
368 case 52:
369 case 53:
370 case 54:
371 case 55:
372 {
373 return 42;
374 }
375 case 3:
376 {
377 return 43;
378 }
379 default:
380 {
381 return -1;
382 }
383 }
384 }
385 case 43:
386 {
387 Lexeme prevMatch = token.match;
388 token.match = lexeme;
389 int tokenId = GetTokenId(4);
390 if (tokenId == CONTINUE_TOKEN)
391 {
392 token.id = tokenId;
393 return -1;
394 }
395 else if (tokenId != INVALID_TOKEN)
396 {
397 token.id = tokenId;
398 }
399 else
400 {
401 token.match = prevMatch;
402 }
403 switch (i)
404 {
405 case 2:
406 case 3:
407 case 5:
408 case 6:
409 case 7:
410 case 8:
411 case 9:
412 case 10:
413 case 11:
414 case 12:
415 case 13:
416 case 14:
417 case 15:
418 case 16:
419 case 17:
420 case 18:
421 case 19:
422 case 20:
423 case 21:
424 case 22:
425 case 23:
426 case 24:
427 case 25:
428 case 26:
429 case 27:
430 case 28:
431 case 29:
432 case 30:
433 case 31:
434 case 32:
435 case 33:
436 case 34:
437 case 35:
438 case 36:
439 case 38:
440 case 39:
441 case 40:
442 case 41:
443 case 42:
444 case 43:
445 case 44:
446 case 45:
447 case 46:
448 case 47:
449 case 48:
450 case 49:
451 case 50:
452 case 51:
453 case 52:
454 case 53:
455 case 54:
456 case 55:
457 {
458 return 7;
459 }
460 case 0:
461 {
462 return 39;
463 }
464 case 1:
465 {
466 return 40;
467 }
468 case 4:
469 {
470 return 41;
471 }
472 case 37:
473 {
474 return 44;
475 }
476 default:
477 {
478 return -1;
479 }
480 }
481 }
482 case 44:
483 {
484 Lexeme prevMatch = token.match;
485 token.match = lexeme;
486 int tokenId = GetTokenId(4);
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 switch (i)
501 {
502 case 2:
503 case 3:
504 case 5:
505 case 6:
506 case 7:
507 case 8:
508 case 9:
509 case 10:
510 case 11:
511 case 12:
512 case 13:
513 case 14:
514 case 15:
515 case 16:
516 case 17:
517 case 18:
518 case 19:
519 case 20:
520 case 21:
521 case 22:
522 case 23:
523 case 24:
524 case 25:
525 case 26:
526 case 27:
527 case 28:
528 case 29:
529 case 30:
530 case 31:
531 case 32:
532 case 33:
533 case 34:
534 case 35:
535 case 36:
536 case 37:
537 case 38:
538 case 39:
539 case 40:
540 case 41:
541 case 42:
542 case 43:
543 case 44:
544 case 45:
545 case 46:
546 case 47:
547 case 48:
548 case 49:
549 case 50:
550 case 51:
551 case 52:
552 case 53:
553 case 54:
554 case 55:
555 {
556 return 7;
557 }
558 case 0:
559 {
560 return 39;
561 }
562 case 1:
563 {
564 return 40;
565 }
566 case 4:
567 {
568 return 41;
569 }
570 default:
571 {
572 return -1;
573 }
574 }
575 }
576 case 42:
577 {
578 switch (i)
579 {
580 case 2:
581 case 3:
582 case 5:
583 case 6:
584 case 7:
585 case 8:
586 case 9:
587 case 10:
588 case 11:
589 case 12:
590 case 13:
591 case 14:
592 case 15:
593 case 16:
594 case 17:
595 case 18:
596 case 19:
597 case 20:
598 case 21:
599 case 22:
600 case 23:
601 case 24:
602 case 25:
603 case 26:
604 case 27:
605 case 28:
606 case 29:
607 case 30:
608 case 31:
609 case 32:
610 case 33:
611 case 34:
612 case 35:
613 case 36:
614 case 37:
615 case 38:
616 case 39:
617 case 40:
618 case 41:
619 case 42:
620 case 43:
621 case 44:
622 case 45:
623 case 46:
624 case 47:
625 case 48:
626 case 49:
627 case 50:
628 case 51:
629 case 52:
630 case 53:
631 case 54:
632 case 55:
633 {
634 return 7;
635 }
636 case 0:
637 {
638 return 39;
639 }
640 case 1:
641 {
642 return 40;
643 }
644 case 4:
645 {
646 return 41;
647 }
648 default:
649 {
650 return -1;
651 }
652 }
653 }
654 case 40:
655 {
656 Lexeme prevMatch = token.match;
657 token.match = lexeme;
658 int tokenId = GetTokenId(4);
659 if (tokenId == CONTINUE_TOKEN)
660 {
661 token.id = tokenId;
662 return -1;
663 }
664 else if (tokenId != INVALID_TOKEN)
665 {
666 token.id = tokenId;
667 }
668 else
669 {
670 token.match = prevMatch;
671 }
672 switch (i)
673 {
674 case 37:
675 {
676 return 45;
677 }
678 default:
679 {
680 return -1;
681 }
682 }
683 }
684 case 45:
685 {
686 Lexeme prevMatch = token.match;
687 token.match = lexeme;
688 int tokenId = GetTokenId(4);
689 if (tokenId == CONTINUE_TOKEN)
690 {
691 token.id = tokenId;
692 return -1;
693 }
694 else if (tokenId != INVALID_TOKEN)
695 {
696 token.id = tokenId;
697 }
698 else
699 {
700 token.match = prevMatch;
701 }
702 switch (i)
703 {
704 case 37:
705 {
706 return 46;
707 }
708 default:
709 {
710 return -1;
711 }
712 }
713 }
714 case 46:
715 {
716 Lexeme prevMatch = token.match;
717 token.match = lexeme;
718 int tokenId = GetTokenId(4);
719 if (tokenId == CONTINUE_TOKEN)
720 {
721 token.id = tokenId;
722 return -1;
723 }
724 else if (tokenId != INVALID_TOKEN)
725 {
726 token.id = tokenId;
727 }
728 else
729 {
730 token.match = prevMatch;
731 }
732 switch (i)
733 {
734 case 37:
735 {
736 return 47;
737 }
738 default:
739 {
740 return -1;
741 }
742 }
743 }
744 case 47:
745 {
746 Lexeme prevMatch = token.match;
747 token.match = lexeme;
748 int tokenId = GetTokenId(4);
749 if (tokenId == CONTINUE_TOKEN)
750 {
751 token.id = tokenId;
752 return -1;
753 }
754 else if (tokenId != INVALID_TOKEN)
755 {
756 token.id = tokenId;
757 }
758 else
759 {
760 token.match = prevMatch;
761 }
762 return -1;
763 }
764 case 39:
765 {
766 Lexeme prevMatch = token.match;
767 token.match = lexeme;
768 int tokenId = GetTokenId(4);
769 if (tokenId == CONTINUE_TOKEN)
770 {
771 token.id = tokenId;
772 return -1;
773 }
774 else if (tokenId != INVALID_TOKEN)
775 {
776 token.id = tokenId;
777 }
778 else
779 {
780 token.match = prevMatch;
781 }
782 switch (i)
783 {
784 case 37:
785 {
786 return 46;
787 }
788 case 1:
789 {
790 return 48;
791 }
792 default:
793 {
794 return -1;
795 }
796 }
797 }
798 case 48:
799 {
800 Lexeme prevMatch = token.match;
801 token.match = lexeme;
802 int tokenId = GetTokenId(4);
803 if (tokenId == CONTINUE_TOKEN)
804 {
805 token.id = tokenId;
806 return -1;
807 }
808 else if (tokenId != INVALID_TOKEN)
809 {
810 token.id = tokenId;
811 }
812 else
813 {
814 token.match = prevMatch;
815 }
816 switch (i)
817 {
818 case 37:
819 {
820 return 45;
821 }
822 default:
823 {
824 return -1;
825 }
826 }
827 }
828 case 37:
829 {
830 Lexeme prevMatch = token.match;
831 token.match = lexeme;
832 int tokenId = GetTokenId(58);
833 if (tokenId == CONTINUE_TOKEN)
834 {
835 token.id = tokenId;
836 return -1;
837 }
838 else if (tokenId != INVALID_TOKEN)
839 {
840 token.id = tokenId;
841 }
842 else
843 {
844 token.match = prevMatch;
845 }
846 switch (i)
847 {
848 case 2:
849 case 3:
850 case 5:
851 case 6:
852 case 7:
853 case 8:
854 case 9:
855 case 10:
856 case 11:
857 case 12:
858 case 13:
859 case 14:
860 case 15:
861 case 16:
862 case 17:
863 case 18:
864 case 19:
865 case 20:
866 case 21:
867 case 22:
868 case 23:
869 case 24:
870 case 25:
871 case 26:
872 case 27:
873 case 28:
874 case 29:
875 case 30:
876 case 31:
877 case 32:
878 case 33:
879 case 34:
880 case 35:
881 case 36:
882 case 37:
883 case 38:
884 case 39:
885 case 40:
886 case 41:
887 case 42:
888 case 43:
889 case 44:
890 case 45:
891 case 46:
892 case 47:
893 case 48:
894 case 49:
895 case 50:
896 case 51:
897 case 52:
898 case 53:
899 case 54:
900 case 55:
901 {
902 return 7;
903 }
904 case 0:
905 {
906 return 39;
907 }
908 case 1:
909 {
910 return 40;
911 }
912 case 4:
913 {
914 return 41;
915 }
916 default:
917 {
918 return -1;
919 }
920 }
921 }
922 case 36:
923 {
924 Lexeme prevMatch = token.match;
925 token.match = lexeme;
926 int tokenId = GetTokenId(56);
927 if (tokenId == CONTINUE_TOKEN)
928 {
929 token.id = tokenId;
930 return -1;
931 }
932 else if (tokenId != INVALID_TOKEN)
933 {
934 token.id = tokenId;
935 }
936 else
937 {
938 token.match = prevMatch;
939 }
940 switch (i)
941 {
942 case 2:
943 case 3:
944 case 5:
945 case 6:
946 case 7:
947 case 8:
948 case 9:
949 case 10:
950 case 11:
951 case 12:
952 case 13:
953 case 14:
954 case 15:
955 case 16:
956 case 17:
957 case 18:
958 case 19:
959 case 20:
960 case 21:
961 case 22:
962 case 23:
963 case 24:
964 case 25:
965 case 26:
966 case 27:
967 case 28:
968 case 29:
969 case 30:
970 case 31:
971 case 32:
972 case 33:
973 case 34:
974 case 35:
975 case 36:
976 case 37:
977 case 38:
978 case 39:
979 case 40:
980 case 41:
981 case 42:
982 case 43:
983 case 44:
984 case 45:
985 case 46:
986 case 47:
987 case 48:
988 case 49:
989 case 50:
990 case 51:
991 case 52:
992 case 53:
993 case 54:
994 case 55:
995 {
996 return 7;
997 }
998 case 0:
999 {
1000 return 39;
1001 }
1002 case 1:
1003 {
1004 return 40;
1005 }
1006 case 4:
1007 {
1008 return 41;
1009 }
1010 default:
1011 {
1012 return -1;
1013 }
1014 }
1015 }
1016 case 35:
1017 {
1018 Lexeme prevMatch = token.match;
1019 token.match = lexeme;
1020 int tokenId = GetTokenId(53);
1021 if (tokenId == CONTINUE_TOKEN)
1022 {
1023 token.id = tokenId;
1024 return -1;
1025 }
1026 else if (tokenId != INVALID_TOKEN)
1027 {
1028 token.id = tokenId;
1029 }
1030 else
1031 {
1032 token.match = prevMatch;
1033 }
1034 switch (i)
1035 {
1036 case 2:
1037 case 3:
1038 case 5:
1039 case 6:
1040 case 7:
1041 case 8:
1042 case 9:
1043 case 10:
1044 case 11:
1045 case 12:
1046 case 13:
1047 case 14:
1048 case 15:
1049 case 16:
1050 case 17:
1051 case 18:
1052 case 19:
1053 case 20:
1054 case 21:
1055 case 22:
1056 case 23:
1057 case 24:
1058 case 25:
1059 case 26:
1060 case 27:
1061 case 28:
1062 case 29:
1063 case 30:
1064 case 31:
1065 case 32:
1066 case 33:
1067 case 34:
1068 case 35:
1069 case 36:
1070 case 37:
1071 case 38:
1072 case 39:
1073 case 40:
1074 case 41:
1075 case 42:
1076 case 43:
1077 case 44:
1078 case 45:
1079 case 46:
1080 case 47:
1081 case 48:
1082 case 49:
1083 case 50:
1084 case 51:
1085 case 52:
1086 case 53:
1087 case 54:
1088 case 55:
1089 {
1090 return 7;
1091 }
1092 case 0:
1093 {
1094 return 39;
1095 }
1096 case 1:
1097 {
1098 return 40;
1099 }
1100 case 4:
1101 {
1102 return 41;
1103 }
1104 default:
1105 {
1106 return -1;
1107 }
1108 }
1109 }
1110 case 34:
1111 {
1112 Lexeme prevMatch = token.match;
1113 token.match = lexeme;
1114 int tokenId = GetTokenId(52);
1115 if (tokenId == CONTINUE_TOKEN)
1116 {
1117 token.id = tokenId;
1118 return -1;
1119 }
1120 else if (tokenId != INVALID_TOKEN)
1121 {
1122 token.id = tokenId;
1123 }
1124 else
1125 {
1126 token.match = prevMatch;
1127 }
1128 switch (i)
1129 {
1130 case 2:
1131 case 3:
1132 case 5:
1133 case 6:
1134 case 7:
1135 case 8:
1136 case 9:
1137 case 10:
1138 case 11:
1139 case 12:
1140 case 13:
1141 case 14:
1142 case 15:
1143 case 16:
1144 case 17:
1145 case 18:
1146 case 19:
1147 case 20:
1148 case 21:
1149 case 22:
1150 case 23:
1151 case 24:
1152 case 25:
1153 case 26:
1154 case 27:
1155 case 28:
1156 case 29:
1157 case 30:
1158 case 31:
1159 case 32:
1160 case 33:
1161 case 34:
1162 case 35:
1163 case 36:
1164 case 37:
1165 case 38:
1166 case 39:
1167 case 40:
1168 case 41:
1169 case 42:
1170 case 43:
1171 case 44:
1172 case 45:
1173 case 46:
1174 case 47:
1175 case 48:
1176 case 49:
1177 case 50:
1178 case 51:
1179 case 52:
1180 case 53:
1181 case 54:
1182 case 55:
1183 {
1184 return 7;
1185 }
1186 case 0:
1187 {
1188 return 39;
1189 }
1190 case 1:
1191 {
1192 return 40;
1193 }
1194 case 4:
1195 {
1196 return 41;
1197 }
1198 default:
1199 {
1200 return -1;
1201 }
1202 }
1203 }
1204 case 33:
1205 {
1206 Lexeme prevMatch = token.match;
1207 token.match = lexeme;
1208 int tokenId = GetTokenId(51);
1209 if (tokenId == CONTINUE_TOKEN)
1210 {
1211 token.id = tokenId;
1212 return -1;
1213 }
1214 else if (tokenId != INVALID_TOKEN)
1215 {
1216 token.id = tokenId;
1217 }
1218 else
1219 {
1220 token.match = prevMatch;
1221 }
1222 switch (i)
1223 {
1224 case 2:
1225 case 3:
1226 case 5:
1227 case 6:
1228 case 7:
1229 case 8:
1230 case 9:
1231 case 10:
1232 case 11:
1233 case 12:
1234 case 13:
1235 case 14:
1236 case 15:
1237 case 16:
1238 case 17:
1239 case 18:
1240 case 19:
1241 case 20:
1242 case 21:
1243 case 22:
1244 case 23:
1245 case 24:
1246 case 25:
1247 case 26:
1248 case 27:
1249 case 28:
1250 case 29:
1251 case 30:
1252 case 31:
1253 case 32:
1254 case 33:
1255 case 34:
1256 case 35:
1257 case 36:
1258 case 37:
1259 case 38:
1260 case 39:
1261 case 40:
1262 case 41:
1263 case 42:
1264 case 43:
1265 case 44:
1266 case 45:
1267 case 46:
1268 case 47:
1269 case 48:
1270 case 49:
1271 case 50:
1272 case 51:
1273 case 52:
1274 case 53:
1275 case 54:
1276 case 55:
1277 {
1278 return 7;
1279 }
1280 case 0:
1281 {
1282 return 39;
1283 }
1284 case 1:
1285 {
1286 return 40;
1287 }
1288 case 4:
1289 {
1290 return 41;
1291 }
1292 default:
1293 {
1294 return -1;
1295 }
1296 }
1297 }
1298 case 32:
1299 {
1300 Lexeme prevMatch = token.match;
1301 token.match = lexeme;
1302 int tokenId = GetTokenId(47);
1303 if (tokenId == CONTINUE_TOKEN)
1304 {
1305 token.id = tokenId;
1306 return -1;
1307 }
1308 else if (tokenId != INVALID_TOKEN)
1309 {
1310 token.id = tokenId;
1311 }
1312 else
1313 {
1314 token.match = prevMatch;
1315 }
1316 switch (i)
1317 {
1318 case 2:
1319 case 3:
1320 case 5:
1321 case 6:
1322 case 7:
1323 case 8:
1324 case 9:
1325 case 10:
1326 case 11:
1327 case 12:
1328 case 13:
1329 case 14:
1330 case 15:
1331 case 16:
1332 case 17:
1333 case 18:
1334 case 19:
1335 case 20:
1336 case 21:
1337 case 22:
1338 case 23:
1339 case 24:
1340 case 25:
1341 case 26:
1342 case 27:
1343 case 28:
1344 case 29:
1345 case 30:
1346 case 31:
1347 case 32:
1348 case 33:
1349 case 34:
1350 case 35:
1351 case 36:
1352 case 37:
1353 case 38:
1354 case 39:
1355 case 40:
1356 case 41:
1357 case 42:
1358 case 43:
1359 case 44:
1360 case 45:
1361 case 46:
1362 case 47:
1363 case 48:
1364 case 49:
1365 case 50:
1366 case 51:
1367 case 52:
1368 case 53:
1369 case 54:
1370 case 55:
1371 {
1372 return 7;
1373 }
1374 case 0:
1375 {
1376 return 39;
1377 }
1378 case 1:
1379 {
1380 return 40;
1381 }
1382 case 4:
1383 {
1384 return 41;
1385 }
1386 default:
1387 {
1388 return -1;
1389 }
1390 }
1391 }
1392 case 31:
1393 {
1394 Lexeme prevMatch = token.match;
1395 token.match = lexeme;
1396 int tokenId = GetTokenId(46);
1397 if (tokenId == CONTINUE_TOKEN)
1398 {
1399 token.id = tokenId;
1400 return -1;
1401 }
1402 else if (tokenId != INVALID_TOKEN)
1403 {
1404 token.id = tokenId;
1405 }
1406 else
1407 {
1408 token.match = prevMatch;
1409 }
1410 switch (i)
1411 {
1412 case 2:
1413 case 3:
1414 case 5:
1415 case 6:
1416 case 7:
1417 case 8:
1418 case 9:
1419 case 10:
1420 case 11:
1421 case 12:
1422 case 13:
1423 case 14:
1424 case 15:
1425 case 16:
1426 case 17:
1427 case 18:
1428 case 19:
1429 case 20:
1430 case 21:
1431 case 22:
1432 case 23:
1433 case 24:
1434 case 25:
1435 case 26:
1436 case 27:
1437 case 28:
1438 case 29:
1439 case 30:
1440 case 31:
1441 case 32:
1442 case 33:
1443 case 34:
1444 case 35:
1445 case 36:
1446 case 37:
1447 case 38:
1448 case 39:
1449 case 40:
1450 case 41:
1451 case 42:
1452 case 43:
1453 case 44:
1454 case 45:
1455 case 46:
1456 case 47:
1457 case 48:
1458 case 49:
1459 case 50:
1460 case 51:
1461 case 52:
1462 case 53:
1463 case 54:
1464 case 55:
1465 {
1466 return 7;
1467 }
1468 case 0:
1469 {
1470 return 39;
1471 }
1472 case 1:
1473 {
1474 return 40;
1475 }
1476 case 4:
1477 {
1478 return 41;
1479 }
1480 default:
1481 {
1482 return -1;
1483 }
1484 }
1485 }
1486 case 30:
1487 {
1488 Lexeme prevMatch = token.match;
1489 token.match = lexeme;
1490 int tokenId = GetTokenId(50);
1491 if (tokenId == CONTINUE_TOKEN)
1492 {
1493 token.id = tokenId;
1494 return -1;
1495 }
1496 else if (tokenId != INVALID_TOKEN)
1497 {
1498 token.id = tokenId;
1499 }
1500 else
1501 {
1502 token.match = prevMatch;
1503 }
1504 switch (i)
1505 {
1506 case 2:
1507 case 3:
1508 case 5:
1509 case 6:
1510 case 7:
1511 case 8:
1512 case 9:
1513 case 10:
1514 case 11:
1515 case 12:
1516 case 13:
1517 case 14:
1518 case 15:
1519 case 16:
1520 case 17:
1521 case 18:
1522 case 19:
1523 case 20:
1524 case 21:
1525 case 22:
1526 case 23:
1527 case 24:
1528 case 25:
1529 case 26:
1530 case 27:
1531 case 28:
1532 case 29:
1533 case 30:
1534 case 31:
1535 case 32:
1536 case 33:
1537 case 34:
1538 case 35:
1539 case 36:
1540 case 37:
1541 case 38:
1542 case 39:
1543 case 41:
1544 case 42:
1545 case 43:
1546 case 44:
1547 case 45:
1548 case 46:
1549 case 47:
1550 case 48:
1551 case 49:
1552 case 50:
1553 case 51:
1554 case 52:
1555 case 53:
1556 case 54:
1557 case 55:
1558 {
1559 return 7;
1560 }
1561 case 0:
1562 {
1563 return 39;
1564 }
1565 case 1:
1566 {
1567 return 40;
1568 }
1569 case 4:
1570 {
1571 return 41;
1572 }
1573 case 40:
1574 {
1575 return 49;
1576 }
1577 default:
1578 {
1579 return -1;
1580 }
1581 }
1582 }
1583 case 49:
1584 {
1585 Lexeme prevMatch = token.match;
1586 token.match = lexeme;
1587 int tokenId = GetTokenId(31);
1588 if (tokenId == CONTINUE_TOKEN)
1589 {
1590 token.id = tokenId;
1591 return -1;
1592 }
1593 else if (tokenId != INVALID_TOKEN)
1594 {
1595 token.id = tokenId;
1596 }
1597 else
1598 {
1599 token.match = prevMatch;
1600 }
1601 switch (i)
1602 {
1603 case 2:
1604 case 3:
1605 case 5:
1606 case 6:
1607 case 7:
1608 case 8:
1609 case 9:
1610 case 10:
1611 case 11:
1612 case 12:
1613 case 13:
1614 case 14:
1615 case 15:
1616 case 16:
1617 case 17:
1618 case 18:
1619 case 19:
1620 case 20:
1621 case 21:
1622 case 22:
1623 case 23:
1624 case 24:
1625 case 25:
1626 case 26:
1627 case 27:
1628 case 28:
1629 case 29:
1630 case 30:
1631 case 31:
1632 case 32:
1633 case 33:
1634 case 34:
1635 case 35:
1636 case 36:
1637 case 37:
1638 case 38:
1639 case 39:
1640 case 40:
1641 case 41:
1642 case 42:
1643 case 43:
1644 case 44:
1645 case 45:
1646 case 46:
1647 case 47:
1648 case 48:
1649 case 49:
1650 case 50:
1651 case 51:
1652 case 52:
1653 case 53:
1654 case 54:
1655 case 55:
1656 {
1657 return 7;
1658 }
1659 case 0:
1660 {
1661 return 39;
1662 }
1663 case 1:
1664 {
1665 return 40;
1666 }
1667 case 4:
1668 {
1669 return 41;
1670 }
1671 default:
1672 {
1673 return -1;
1674 }
1675 }
1676 }
1677 case 29:
1678 {
1679 Lexeme prevMatch = token.match;
1680 token.match = lexeme;
1681 int tokenId = GetTokenId(27);
1682 if (tokenId == CONTINUE_TOKEN)
1683 {
1684 token.id = tokenId;
1685 return -1;
1686 }
1687 else if (tokenId != INVALID_TOKEN)
1688 {
1689 token.id = tokenId;
1690 }
1691 else
1692 {
1693 token.match = prevMatch;
1694 }
1695 switch (i)
1696 {
1697 case 2:
1698 case 3:
1699 case 5:
1700 case 6:
1701 case 7:
1702 case 8:
1703 case 9:
1704 case 10:
1705 case 11:
1706 case 12:
1707 case 13:
1708 case 14:
1709 case 15:
1710 case 16:
1711 case 17:
1712 case 18:
1713 case 19:
1714 case 20:
1715 case 21:
1716 case 22:
1717 case 23:
1718 case 24:
1719 case 25:
1720 case 26:
1721 case 27:
1722 case 28:
1723 case 29:
1724 case 30:
1725 case 31:
1726 case 32:
1727 case 33:
1728 case 34:
1729 case 35:
1730 case 36:
1731 case 37:
1732 case 38:
1733 case 39:
1734 case 41:
1735 case 42:
1736 case 43:
1737 case 44:
1738 case 45:
1739 case 47:
1740 case 48:
1741 case 49:
1742 case 50:
1743 case 51:
1744 case 52:
1745 case 53:
1746 case 54:
1747 case 55:
1748 {
1749 return 7;
1750 }
1751 case 0:
1752 {
1753 return 39;
1754 }
1755 case 1:
1756 {
1757 return 40;
1758 }
1759 case 4:
1760 {
1761 return 41;
1762 }
1763 case 40:
1764 {
1765 return 50;
1766 }
1767 case 46:
1768 {
1769 return 51;
1770 }
1771 default:
1772 {
1773 return -1;
1774 }
1775 }
1776 }
1777 case 51:
1778 {
1779 Lexeme prevMatch = token.match;
1780 token.match = lexeme;
1781 int tokenId = GetTokenId(25);
1782 if (tokenId == CONTINUE_TOKEN)
1783 {
1784 token.id = tokenId;
1785 return -1;
1786 }
1787 else if (tokenId != INVALID_TOKEN)
1788 {
1789 token.id = tokenId;
1790 }
1791 else
1792 {
1793 token.match = prevMatch;
1794 }
1795 switch (i)
1796 {
1797 case 2:
1798 case 3:
1799 case 5:
1800 case 6:
1801 case 7:
1802 case 8:
1803 case 9:
1804 case 10:
1805 case 11:
1806 case 12:
1807 case 13:
1808 case 14:
1809 case 15:
1810 case 16:
1811 case 17:
1812 case 18:
1813 case 19:
1814 case 20:
1815 case 21:
1816 case 22:
1817 case 23:
1818 case 24:
1819 case 25:
1820 case 26:
1821 case 27:
1822 case 28:
1823 case 29:
1824 case 30:
1825 case 31:
1826 case 32:
1827 case 33:
1828 case 34:
1829 case 35:
1830 case 36:
1831 case 37:
1832 case 38:
1833 case 39:
1834 case 40:
1835 case 41:
1836 case 42:
1837 case 43:
1838 case 44:
1839 case 45:
1840 case 46:
1841 case 47:
1842 case 48:
1843 case 49:
1844 case 50:
1845 case 51:
1846 case 52:
1847 case 53:
1848 case 54:
1849 case 55:
1850 {
1851 return 7;
1852 }
1853 case 0:
1854 {
1855 return 39;
1856 }
1857 case 1:
1858 {
1859 return 40;
1860 }
1861 case 4:
1862 {
1863 return 41;
1864 }
1865 default:
1866 {
1867 return -1;
1868 }
1869 }
1870 }
1871 case 50:
1872 {
1873 Lexeme prevMatch = token.match;
1874 token.match = lexeme;
1875 int tokenId = GetTokenId(22);
1876 if (tokenId == CONTINUE_TOKEN)
1877 {
1878 token.id = tokenId;
1879 return -1;
1880 }
1881 else if (tokenId != INVALID_TOKEN)
1882 {
1883 token.id = tokenId;
1884 }
1885 else
1886 {
1887 token.match = prevMatch;
1888 }
1889 switch (i)
1890 {
1891 case 2:
1892 case 3:
1893 case 5:
1894 case 6:
1895 case 7:
1896 case 8:
1897 case 9:
1898 case 10:
1899 case 11:
1900 case 12:
1901 case 13:
1902 case 14:
1903 case 15:
1904 case 16:
1905 case 17:
1906 case 18:
1907 case 19:
1908 case 20:
1909 case 21:
1910 case 22:
1911 case 23:
1912 case 24:
1913 case 25:
1914 case 26:
1915 case 27:
1916 case 28:
1917 case 29:
1918 case 30:
1919 case 31:
1920 case 32:
1921 case 33:
1922 case 34:
1923 case 35:
1924 case 36:
1925 case 37:
1926 case 38:
1927 case 39:
1928 case 40:
1929 case 41:
1930 case 42:
1931 case 43:
1932 case 44:
1933 case 45:
1934 case 46:
1935 case 47:
1936 case 48:
1937 case 49:
1938 case 50:
1939 case 51:
1940 case 52:
1941 case 53:
1942 case 54:
1943 case 55:
1944 {
1945 return 7;
1946 }
1947 case 0:
1948 {
1949 return 39;
1950 }
1951 case 1:
1952 {
1953 return 40;
1954 }
1955 case 4:
1956 {
1957 return 41;
1958 }
1959 default:
1960 {
1961 return -1;
1962 }
1963 }
1964 }
1965 case 28:
1966 {
1967 Lexeme prevMatch = token.match;
1968 token.match = lexeme;
1969 int tokenId = GetTokenId(28);
1970 if (tokenId == CONTINUE_TOKEN)
1971 {
1972 token.id = tokenId;
1973 return -1;
1974 }
1975 else if (tokenId != INVALID_TOKEN)
1976 {
1977 token.id = tokenId;
1978 }
1979 else
1980 {
1981 token.match = prevMatch;
1982 }
1983 switch (i)
1984 {
1985 case 2:
1986 case 3:
1987 case 5:
1988 case 6:
1989 case 7:
1990 case 8:
1991 case 9:
1992 case 10:
1993 case 11:
1994 case 12:
1995 case 13:
1996 case 14:
1997 case 15:
1998 case 16:
1999 case 17:
2000 case 18:
2001 case 19:
2002 case 20:
2003 case 21:
2004 case 22:
2005 case 23:
2006 case 24:
2007 case 25:
2008 case 26:
2009 case 27:
2010 case 28:
2011 case 29:
2012 case 30:
2013 case 31:
2014 case 32:
2015 case 33:
2016 case 34:
2017 case 35:
2018 case 36:
2019 case 37:
2020 case 38:
2021 case 39:
2022 case 41:
2023 case 42:
2024 case 43:
2025 case 44:
2026 case 45:
2027 case 46:
2028 case 47:
2029 case 48:
2030 case 49:
2031 case 50:
2032 case 51:
2033 case 52:
2034 case 53:
2035 case 54:
2036 case 55:
2037 {
2038 return 7;
2039 }
2040 case 0:
2041 {
2042 return 39;
2043 }
2044 case 1:
2045 {
2046 return 40;
2047 }
2048 case 4:
2049 {
2050 return 41;
2051 }
2052 case 40:
2053 {
2054 return 52;
2055 }
2056 default:
2057 {
2058 return -1;
2059 }
2060 }
2061 }
2062 case 52:
2063 {
2064 Lexeme prevMatch = token.match;
2065 token.match = lexeme;
2066 int tokenId = GetTokenId(21);
2067 if (tokenId == CONTINUE_TOKEN)
2068 {
2069 token.id = tokenId;
2070 return -1;
2071 }
2072 else if (tokenId != INVALID_TOKEN)
2073 {
2074 token.id = tokenId;
2075 }
2076 else
2077 {
2078 token.match = prevMatch;
2079 }
2080 switch (i)
2081 {
2082 case 2:
2083 case 3:
2084 case 5:
2085 case 6:
2086 case 7:
2087 case 8:
2088 case 9:
2089 case 10:
2090 case 11:
2091 case 12:
2092 case 13:
2093 case 14:
2094 case 15:
2095 case 16:
2096 case 17:
2097 case 18:
2098 case 19:
2099 case 20:
2100 case 21:
2101 case 22:
2102 case 23:
2103 case 24:
2104 case 25:
2105 case 26:
2106 case 27:
2107 case 28:
2108 case 29:
2109 case 30:
2110 case 31:
2111 case 32:
2112 case 33:
2113 case 34:
2114 case 35:
2115 case 36:
2116 case 37:
2117 case 38:
2118 case 39:
2119 case 40:
2120 case 41:
2121 case 42:
2122 case 43:
2123 case 44:
2124 case 45:
2125 case 46:
2126 case 47:
2127 case 48:
2128 case 49:
2129 case 50:
2130 case 51:
2131 case 52:
2132 case 53:
2133 case 54:
2134 case 55:
2135 {
2136 return 7;
2137 }
2138 case 0:
2139 {
2140 return 39;
2141 }
2142 case 1:
2143 {
2144 return 40;
2145 }
2146 case 4:
2147 {
2148 return 41;
2149 }
2150 default:
2151 {
2152 return -1;
2153 }
2154 }
2155 }
2156 case 27:
2157 {
2158 Lexeme prevMatch = token.match;
2159 token.match = lexeme;
2160 int tokenId = GetTokenId(29);
2161 if (tokenId == CONTINUE_TOKEN)
2162 {
2163 token.id = tokenId;
2164 return -1;
2165 }
2166 else if (tokenId != INVALID_TOKEN)
2167 {
2168 token.id = tokenId;
2169 }
2170 else
2171 {
2172 token.match = prevMatch;
2173 }
2174 switch (i)
2175 {
2176 case 2:
2177 case 3:
2178 case 5:
2179 case 6:
2180 case 7:
2181 case 8:
2182 case 9:
2183 case 10:
2184 case 11:
2185 case 12:
2186 case 13:
2187 case 14:
2188 case 15:
2189 case 16:
2190 case 17:
2191 case 18:
2192 case 19:
2193 case 20:
2194 case 21:
2195 case 22:
2196 case 23:
2197 case 24:
2198 case 25:
2199 case 26:
2200 case 27:
2201 case 28:
2202 case 29:
2203 case 30:
2204 case 31:
2205 case 32:
2206 case 33:
2207 case 34:
2208 case 35:
2209 case 36:
2210 case 37:
2211 case 38:
2212 case 39:
2213 case 41:
2214 case 42:
2215 case 43:
2216 case 45:
2217 case 46:
2218 case 47:
2219 case 48:
2220 case 49:
2221 case 50:
2222 case 51:
2223 case 52:
2224 case 53:
2225 case 54:
2226 case 55:
2227 {
2228 return 7;
2229 }
2230 case 0:
2231 {
2232 return 39;
2233 }
2234 case 1:
2235 {
2236 return 40;
2237 }
2238 case 4:
2239 {
2240 return 41;
2241 }
2242 case 40:
2243 {
2244 return 53;
2245 }
2246 case 44:
2247 {
2248 return 54;
2249 }
2250 default:
2251 {
2252 return -1;
2253 }
2254 }
2255 }
2256 case 54:
2257 {
2258 Lexeme prevMatch = token.match;
2259 token.match = lexeme;
2260 int tokenId = GetTokenId(26);
2261 if (tokenId == CONTINUE_TOKEN)
2262 {
2263 token.id = tokenId;
2264 return -1;
2265 }
2266 else if (tokenId != INVALID_TOKEN)
2267 {
2268 token.id = tokenId;
2269 }
2270 else
2271 {
2272 token.match = prevMatch;
2273 }
2274 switch (i)
2275 {
2276 case 2:
2277 case 3:
2278 case 5:
2279 case 6:
2280 case 7:
2281 case 8:
2282 case 9:
2283 case 10:
2284 case 11:
2285 case 12:
2286 case 13:
2287 case 14:
2288 case 15:
2289 case 16:
2290 case 17:
2291 case 18:
2292 case 19:
2293 case 20:
2294 case 21:
2295 case 22:
2296 case 23:
2297 case 24:
2298 case 25:
2299 case 26:
2300 case 27:
2301 case 28:
2302 case 29:
2303 case 30:
2304 case 31:
2305 case 32:
2306 case 33:
2307 case 34:
2308 case 35:
2309 case 36:
2310 case 37:
2311 case 38:
2312 case 39:
2313 case 40:
2314 case 41:
2315 case 42:
2316 case 43:
2317 case 44:
2318 case 45:
2319 case 46:
2320 case 47:
2321 case 48:
2322 case 49:
2323 case 50:
2324 case 51:
2325 case 52:
2326 case 53:
2327 case 54:
2328 case 55:
2329 {
2330 return 7;
2331 }
2332 case 0:
2333 {
2334 return 39;
2335 }
2336 case 1:
2337 {
2338 return 40;
2339 }
2340 case 4:
2341 {
2342 return 41;
2343 }
2344 default:
2345 {
2346 return -1;
2347 }
2348 }
2349 }
2350 case 53:
2351 {
2352 Lexeme prevMatch = token.match;
2353 token.match = lexeme;
2354 int tokenId = GetTokenId(20);
2355 if (tokenId == CONTINUE_TOKEN)
2356 {
2357 token.id = tokenId;
2358 return -1;
2359 }
2360 else if (tokenId != INVALID_TOKEN)
2361 {
2362 token.id = tokenId;
2363 }
2364 else
2365 {
2366 token.match = prevMatch;
2367 }
2368 switch (i)
2369 {
2370 case 2:
2371 case 3:
2372 case 5:
2373 case 6:
2374 case 7:
2375 case 8:
2376 case 9:
2377 case 10:
2378 case 11:
2379 case 12:
2380 case 13:
2381 case 14:
2382 case 15:
2383 case 16:
2384 case 17:
2385 case 18:
2386 case 19:
2387 case 20:
2388 case 21:
2389 case 22:
2390 case 23:
2391 case 24:
2392 case 25:
2393 case 26:
2394 case 27:
2395 case 28:
2396 case 29:
2397 case 30:
2398 case 31:
2399 case 32:
2400 case 33:
2401 case 34:
2402 case 35:
2403 case 36:
2404 case 37:
2405 case 38:
2406 case 39:
2407 case 40:
2408 case 41:
2409 case 42:
2410 case 43:
2411 case 44:
2412 case 45:
2413 case 46:
2414 case 47:
2415 case 48:
2416 case 49:
2417 case 50:
2418 case 51:
2419 case 52:
2420 case 53:
2421 case 54:
2422 case 55:
2423 {
2424 return 7;
2425 }
2426 case 0:
2427 {
2428 return 39;
2429 }
2430 case 1:
2431 {
2432 return 40;
2433 }
2434 case 4:
2435 {
2436 return 41;
2437 }
2438 default:
2439 {
2440 return -1;
2441 }
2442 }
2443 }
2444 case 26:
2445 {
2446 Lexeme prevMatch = token.match;
2447 token.match = lexeme;
2448 int tokenId = GetTokenId(35);
2449 if (tokenId == CONTINUE_TOKEN)
2450 {
2451 token.id = tokenId;
2452 return -1;
2453 }
2454 else if (tokenId != INVALID_TOKEN)
2455 {
2456 token.id = tokenId;
2457 }
2458 else
2459 {
2460 token.match = prevMatch;
2461 }
2462 switch (i)
2463 {
2464 case 2:
2465 case 3:
2466 case 5:
2467 case 6:
2468 case 7:
2469 case 8:
2470 case 9:
2471 case 10:
2472 case 11:
2473 case 12:
2474 case 13:
2475 case 14:
2476 case 15:
2477 case 16:
2478 case 17:
2479 case 18:
2480 case 19:
2481 case 20:
2482 case 21:
2483 case 22:
2484 case 23:
2485 case 24:
2486 case 25:
2487 case 26:
2488 case 27:
2489 case 28:
2490 case 29:
2491 case 30:
2492 case 31:
2493 case 32:
2494 case 33:
2495 case 34:
2496 case 35:
2497 case 36:
2498 case 37:
2499 case 38:
2500 case 39:
2501 case 41:
2502 case 42:
2503 case 44:
2504 case 45:
2505 case 46:
2506 case 47:
2507 case 48:
2508 case 49:
2509 case 50:
2510 case 51:
2511 case 52:
2512 case 53:
2513 case 54:
2514 case 55:
2515 {
2516 return 7;
2517 }
2518 case 0:
2519 {
2520 return 39;
2521 }
2522 case 1:
2523 {
2524 return 40;
2525 }
2526 case 4:
2527 {
2528 return 41;
2529 }
2530 case 40:
2531 {
2532 return 55;
2533 }
2534 case 43:
2535 {
2536 return 56;
2537 }
2538 default:
2539 {
2540 return -1;
2541 }
2542 }
2543 }
2544 case 56:
2545 {
2546 Lexeme prevMatch = token.match;
2547 token.match = lexeme;
2548 int tokenId = GetTokenId(37);
2549 if (tokenId == CONTINUE_TOKEN)
2550 {
2551 token.id = tokenId;
2552 return -1;
2553 }
2554 else if (tokenId != INVALID_TOKEN)
2555 {
2556 token.id = tokenId;
2557 }
2558 else
2559 {
2560 token.match = prevMatch;
2561 }
2562 switch (i)
2563 {
2564 case 2:
2565 case 3:
2566 case 5:
2567 case 6:
2568 case 7:
2569 case 8:
2570 case 9:
2571 case 10:
2572 case 11:
2573 case 12:
2574 case 13:
2575 case 14:
2576 case 15:
2577 case 16:
2578 case 17:
2579 case 18:
2580 case 19:
2581 case 20:
2582 case 21:
2583 case 22:
2584 case 23:
2585 case 24:
2586 case 25:
2587 case 26:
2588 case 27:
2589 case 28:
2590 case 29:
2591 case 30:
2592 case 31:
2593 case 32:
2594 case 33:
2595 case 34:
2596 case 35:
2597 case 36:
2598 case 37:
2599 case 38:
2600 case 39:
2601 case 41:
2602 case 42:
2603 case 43:
2604 case 44:
2605 case 45:
2606 case 46:
2607 case 47:
2608 case 48:
2609 case 49:
2610 case 50:
2611 case 51:
2612 case 52:
2613 case 53:
2614 case 54:
2615 case 55:
2616 {
2617 return 7;
2618 }
2619 case 0:
2620 {
2621 return 39;
2622 }
2623 case 1:
2624 {
2625 return 40;
2626 }
2627 case 4:
2628 {
2629 return 41;
2630 }
2631 case 40:
2632 {
2633 return 57;
2634 }
2635 default:
2636 {
2637 return -1;
2638 }
2639 }
2640 }
2641 case 57:
2642 {
2643 Lexeme prevMatch = token.match;
2644 token.match = lexeme;
2645 int tokenId = GetTokenId(19);
2646 if (tokenId == CONTINUE_TOKEN)
2647 {
2648 token.id = tokenId;
2649 return -1;
2650 }
2651 else if (tokenId != INVALID_TOKEN)
2652 {
2653 token.id = tokenId;
2654 }
2655 else
2656 {
2657 token.match = prevMatch;
2658 }
2659 switch (i)
2660 {
2661 case 2:
2662 case 3:
2663 case 5:
2664 case 6:
2665 case 7:
2666 case 8:
2667 case 9:
2668 case 10:
2669 case 11:
2670 case 12:
2671 case 13:
2672 case 14:
2673 case 15:
2674 case 16:
2675 case 17:
2676 case 18:
2677 case 19:
2678 case 20:
2679 case 21:
2680 case 22:
2681 case 23:
2682 case 24:
2683 case 25:
2684 case 26:
2685 case 27:
2686 case 28:
2687 case 29:
2688 case 30:
2689 case 31:
2690 case 32:
2691 case 33:
2692 case 34:
2693 case 35:
2694 case 36:
2695 case 37:
2696 case 38:
2697 case 39:
2698 case 40:
2699 case 41:
2700 case 42:
2701 case 43:
2702 case 44:
2703 case 45:
2704 case 46:
2705 case 47:
2706 case 48:
2707 case 49:
2708 case 50:
2709 case 51:
2710 case 52:
2711 case 53:
2712 case 54:
2713 case 55:
2714 {
2715 return 7;
2716 }
2717 case 0:
2718 {
2719 return 39;
2720 }
2721 case 1:
2722 {
2723 return 40;
2724 }
2725 case 4:
2726 {
2727 return 41;
2728 }
2729 default:
2730 {
2731 return -1;
2732 }
2733 }
2734 }
2735 case 55:
2736 {
2737 Lexeme prevMatch = token.match;
2738 token.match = lexeme;
2739 int tokenId = GetTokenId(32);
2740 if (tokenId == CONTINUE_TOKEN)
2741 {
2742 token.id = tokenId;
2743 return -1;
2744 }
2745 else if (tokenId != INVALID_TOKEN)
2746 {
2747 token.id = tokenId;
2748 }
2749 else
2750 {
2751 token.match = prevMatch;
2752 }
2753 switch (i)
2754 {
2755 case 2:
2756 case 3:
2757 case 5:
2758 case 6:
2759 case 7:
2760 case 8:
2761 case 9:
2762 case 10:
2763 case 11:
2764 case 12:
2765 case 13:
2766 case 14:
2767 case 15:
2768 case 16:
2769 case 17:
2770 case 18:
2771 case 19:
2772 case 20:
2773 case 21:
2774 case 22:
2775 case 23:
2776 case 24:
2777 case 25:
2778 case 26:
2779 case 27:
2780 case 28:
2781 case 29:
2782 case 30:
2783 case 31:
2784 case 32:
2785 case 33:
2786 case 34:
2787 case 35:
2788 case 36:
2789 case 37:
2790 case 38:
2791 case 39:
2792 case 40:
2793 case 41:
2794 case 43:
2795 case 44:
2796 case 45:
2797 case 46:
2798 case 47:
2799 case 48:
2800 case 49:
2801 case 50:
2802 case 51:
2803 case 52:
2804 case 53:
2805 case 54:
2806 case 55:
2807 {
2808 return 7;
2809 }
2810 case 0:
2811 {
2812 return 39;
2813 }
2814 case 1:
2815 {
2816 return 40;
2817 }
2818 case 4:
2819 {
2820 return 41;
2821 }
2822 case 42:
2823 {
2824 return 58;
2825 }
2826 default:
2827 {
2828 return -1;
2829 }
2830 }
2831 }
2832 case 58:
2833 {
2834 Lexeme prevMatch = token.match;
2835 token.match = lexeme;
2836 int tokenId = GetTokenId(34);
2837 if (tokenId == CONTINUE_TOKEN)
2838 {
2839 token.id = tokenId;
2840 return -1;
2841 }
2842 else if (tokenId != INVALID_TOKEN)
2843 {
2844 token.id = tokenId;
2845 }
2846 else
2847 {
2848 token.match = prevMatch;
2849 }
2850 switch (i)
2851 {
2852 case 2:
2853 case 3:
2854 case 5:
2855 case 6:
2856 case 7:
2857 case 8:
2858 case 9:
2859 case 10:
2860 case 11:
2861 case 12:
2862 case 13:
2863 case 14:
2864 case 15:
2865 case 16:
2866 case 17:
2867 case 18:
2868 case 19:
2869 case 20:
2870 case 21:
2871 case 22:
2872 case 23:
2873 case 24:
2874 case 25:
2875 case 26:
2876 case 27:
2877 case 28:
2878 case 29:
2879 case 30:
2880 case 31:
2881 case 32:
2882 case 33:
2883 case 34:
2884 case 35:
2885 case 36:
2886 case 37:
2887 case 38:
2888 case 39:
2889 case 40:
2890 case 41:
2891 case 42:
2892 case 43:
2893 case 44:
2894 case 45:
2895 case 46:
2896 case 47:
2897 case 48:
2898 case 49:
2899 case 50:
2900 case 51:
2901 case 52:
2902 case 53:
2903 case 54:
2904 case 55:
2905 {
2906 return 7;
2907 }
2908 case 0:
2909 {
2910 return 39;
2911 }
2912 case 1:
2913 {
2914 return 40;
2915 }
2916 case 4:
2917 {
2918 return 41;
2919 }
2920 default:
2921 {
2922 return -1;
2923 }
2924 }
2925 }
2926 case 25:
2927 {
2928 Lexeme prevMatch = token.match;
2929 token.match = lexeme;
2930 int tokenId = GetTokenId(36);
2931 if (tokenId == CONTINUE_TOKEN)
2932 {
2933 token.id = tokenId;
2934 return -1;
2935 }
2936 else if (tokenId != INVALID_TOKEN)
2937 {
2938 token.id = tokenId;
2939 }
2940 else
2941 {
2942 token.match = prevMatch;
2943 }
2944 switch (i)
2945 {
2946 case 2:
2947 case 3:
2948 case 5:
2949 case 6:
2950 case 7:
2951 case 8:
2952 case 9:
2953 case 10:
2954 case 11:
2955 case 12:
2956 case 13:
2957 case 14:
2958 case 15:
2959 case 16:
2960 case 17:
2961 case 18:
2962 case 19:
2963 case 20:
2964 case 21:
2965 case 22:
2966 case 23:
2967 case 24:
2968 case 25:
2969 case 26:
2970 case 27:
2971 case 28:
2972 case 29:
2973 case 30:
2974 case 31:
2975 case 32:
2976 case 33:
2977 case 34:
2978 case 35:
2979 case 36:
2980 case 37:
2981 case 38:
2982 case 39:
2983 case 41:
2984 case 43:
2985 case 44:
2986 case 45:
2987 case 46:
2988 case 47:
2989 case 48:
2990 case 49:
2991 case 50:
2992 case 51:
2993 case 52:
2994 case 53:
2995 case 54:
2996 case 55:
2997 {
2998 return 7;
2999 }
3000 case 0:
3001 {
3002 return 39;
3003 }
3004 case 1:
3005 {
3006 return 40;
3007 }
3008 case 4:
3009 {
3010 return 41;
3011 }
3012 case 40:
3013 {
3014 return 59;
3015 }
3016 case 42:
3017 {
3018 return 60;
3019 }
3020 default:
3021 {
3022 return -1;
3023 }
3024 }
3025 }
3026 case 60:
3027 {
3028 Lexeme prevMatch = token.match;
3029 token.match = lexeme;
3030 int tokenId = GetTokenId(38);
3031 if (tokenId == CONTINUE_TOKEN)
3032 {
3033 token.id = tokenId;
3034 return -1;
3035 }
3036 else if (tokenId != INVALID_TOKEN)
3037 {
3038 token.id = tokenId;
3039 }
3040 else
3041 {
3042 token.match = prevMatch;
3043 }
3044 switch (i)
3045 {
3046 case 2:
3047 case 3:
3048 case 5:
3049 case 6:
3050 case 7:
3051 case 8:
3052 case 9:
3053 case 10:
3054 case 11:
3055 case 12:
3056 case 13:
3057 case 14:
3058 case 15:
3059 case 16:
3060 case 17:
3061 case 18:
3062 case 19:
3063 case 20:
3064 case 21:
3065 case 22:
3066 case 23:
3067 case 24:
3068 case 25:
3069 case 26:
3070 case 27:
3071 case 28:
3072 case 29:
3073 case 30:
3074 case 31:
3075 case 32:
3076 case 33:
3077 case 34:
3078 case 35:
3079 case 36:
3080 case 37:
3081 case 38:
3082 case 39:
3083 case 41:
3084 case 42:
3085 case 43:
3086 case 44:
3087 case 45:
3088 case 46:
3089 case 47:
3090 case 48:
3091 case 49:
3092 case 50:
3093 case 51:
3094 case 52:
3095 case 53:
3096 case 54:
3097 case 55:
3098 {
3099 return 7;
3100 }
3101 case 0:
3102 {
3103 return 39;
3104 }
3105 case 1:
3106 {
3107 return 40;
3108 }
3109 case 4:
3110 {
3111 return 41;
3112 }
3113 case 40:
3114 {
3115 return 61;
3116 }
3117 default:
3118 {
3119 return -1;
3120 }
3121 }
3122 }
3123 case 61:
3124 {
3125 Lexeme prevMatch = token.match;
3126 token.match = lexeme;
3127 int tokenId = GetTokenId(18);
3128 if (tokenId == CONTINUE_TOKEN)
3129 {
3130 token.id = tokenId;
3131 return -1;
3132 }
3133 else if (tokenId != INVALID_TOKEN)
3134 {
3135 token.id = tokenId;
3136 }
3137 else
3138 {
3139 token.match = prevMatch;
3140 }
3141 switch (i)
3142 {
3143 case 2:
3144 case 3:
3145 case 5:
3146 case 6:
3147 case 7:
3148 case 8:
3149 case 9:
3150 case 10:
3151 case 11:
3152 case 12:
3153 case 13:
3154 case 14:
3155 case 15:
3156 case 16:
3157 case 17:
3158 case 18:
3159 case 19:
3160 case 20:
3161 case 21:
3162 case 22:
3163 case 23:
3164 case 24:
3165 case 25:
3166 case 26:
3167 case 27:
3168 case 28:
3169 case 29:
3170 case 30:
3171 case 31:
3172 case 32:
3173 case 33:
3174 case 34:
3175 case 35:
3176 case 36:
3177 case 37:
3178 case 38:
3179 case 39:
3180 case 40:
3181 case 41:
3182 case 42:
3183 case 43:
3184 case 44:
3185 case 45:
3186 case 46:
3187 case 47:
3188 case 48:
3189 case 49:
3190 case 50:
3191 case 51:
3192 case 52:
3193 case 53:
3194 case 54:
3195 case 55:
3196 {
3197 return 7;
3198 }
3199 case 0:
3200 {
3201 return 39;
3202 }
3203 case 1:
3204 {
3205 return 40;
3206 }
3207 case 4:
3208 {
3209 return 41;
3210 }
3211 default:
3212 {
3213 return -1;
3214 }
3215 }
3216 }
3217 case 59:
3218 {
3219 Lexeme prevMatch = token.match;
3220 token.match = lexeme;
3221 int tokenId = GetTokenId(33);
3222 if (tokenId == CONTINUE_TOKEN)
3223 {
3224 token.id = tokenId;
3225 return -1;
3226 }
3227 else if (tokenId != INVALID_TOKEN)
3228 {
3229 token.id = tokenId;
3230 }
3231 else
3232 {
3233 token.match = prevMatch;
3234 }
3235 switch (i)
3236 {
3237 case 2:
3238 case 3:
3239 case 5:
3240 case 6:
3241 case 7:
3242 case 8:
3243 case 9:
3244 case 10:
3245 case 11:
3246 case 12:
3247 case 13:
3248 case 14:
3249 case 15:
3250 case 16:
3251 case 17:
3252 case 18:
3253 case 19:
3254 case 20:
3255 case 21:
3256 case 22:
3257 case 23:
3258 case 24:
3259 case 25:
3260 case 26:
3261 case 27:
3262 case 28:
3263 case 29:
3264 case 30:
3265 case 31:
3266 case 32:
3267 case 33:
3268 case 34:
3269 case 35:
3270 case 36:
3271 case 37:
3272 case 38:
3273 case 39:
3274 case 40:
3275 case 41:
3276 case 42:
3277 case 43:
3278 case 44:
3279 case 45:
3280 case 46:
3281 case 47:
3282 case 48:
3283 case 49:
3284 case 50:
3285 case 51:
3286 case 52:
3287 case 53:
3288 case 54:
3289 case 55:
3290 {
3291 return 7;
3292 }
3293 case 0:
3294 {
3295 return 39;
3296 }
3297 case 1:
3298 {
3299 return 40;
3300 }
3301 case 4:
3302 {
3303 return 41;
3304 }
3305 default:
3306 {
3307 return -1;
3308 }
3309 }
3310 }
3311 case 24:
3312 {
3313 Lexeme prevMatch = token.match;
3314 token.match = lexeme;
3315 int tokenId = GetTokenId(43);
3316 if (tokenId == CONTINUE_TOKEN)
3317 {
3318 token.id = tokenId;
3319 return -1;
3320 }
3321 else if (tokenId != INVALID_TOKEN)
3322 {
3323 token.id = tokenId;
3324 }
3325 else
3326 {
3327 token.match = prevMatch;
3328 }
3329 switch (i)
3330 {
3331 case 2:
3332 case 3:
3333 case 5:
3334 case 6:
3335 case 7:
3336 case 8:
3337 case 9:
3338 case 10:
3339 case 11:
3340 case 12:
3341 case 13:
3342 case 14:
3343 case 15:
3344 case 16:
3345 case 17:
3346 case 18:
3347 case 19:
3348 case 20:
3349 case 21:
3350 case 22:
3351 case 23:
3352 case 24:
3353 case 25:
3354 case 26:
3355 case 27:
3356 case 28:
3357 case 29:
3358 case 30:
3359 case 31:
3360 case 32:
3361 case 33:
3362 case 34:
3363 case 35:
3364 case 36:
3365 case 37:
3366 case 38:
3367 case 39:
3368 case 41:
3369 case 42:
3370 case 43:
3371 case 44:
3372 case 45:
3373 case 46:
3374 case 47:
3375 case 48:
3376 case 49:
3377 case 50:
3378 case 51:
3379 case 52:
3380 case 53:
3381 case 54:
3382 case 55:
3383 {
3384 return 7;
3385 }
3386 case 0:
3387 {
3388 return 39;
3389 }
3390 case 1:
3391 {
3392 return 40;
3393 }
3394 case 4:
3395 {
3396 return 41;
3397 }
3398 case 40:
3399 {
3400 return 62;
3401 }
3402 default:
3403 {
3404 return -1;
3405 }
3406 }
3407 }
3408 case 62:
3409 {
3410 Lexeme prevMatch = token.match;
3411 token.match = lexeme;
3412 int tokenId = GetTokenId(15);
3413 if (tokenId == CONTINUE_TOKEN)
3414 {
3415 token.id = tokenId;
3416 return -1;
3417 }
3418 else if (tokenId != INVALID_TOKEN)
3419 {
3420 token.id = tokenId;
3421 }
3422 else
3423 {
3424 token.match = prevMatch;
3425 }
3426 switch (i)
3427 {
3428 case 2:
3429 case 3:
3430 case 5:
3431 case 6:
3432 case 7:
3433 case 8:
3434 case 9:
3435 case 10:
3436 case 11:
3437 case 12:
3438 case 13:
3439 case 14:
3440 case 15:
3441 case 16:
3442 case 17:
3443 case 18:
3444 case 19:
3445 case 20:
3446 case 21:
3447 case 22:
3448 case 23:
3449 case 24:
3450 case 25:
3451 case 26:
3452 case 27:
3453 case 28:
3454 case 29:
3455 case 30:
3456 case 31:
3457 case 32:
3458 case 33:
3459 case 34:
3460 case 35:
3461 case 36:
3462 case 37:
3463 case 38:
3464 case 39:
3465 case 40:
3466 case 41:
3467 case 42:
3468 case 43:
3469 case 44:
3470 case 45:
3471 case 46:
3472 case 47:
3473 case 48:
3474 case 49:
3475 case 50:
3476 case 51:
3477 case 52:
3478 case 53:
3479 case 54:
3480 case 55:
3481 {
3482 return 7;
3483 }
3484 case 0:
3485 {
3486 return 39;
3487 }
3488 case 1:
3489 {
3490 return 40;
3491 }
3492 case 4:
3493 {
3494 return 41;
3495 }
3496 default:
3497 {
3498 return -1;
3499 }
3500 }
3501 }
3502 case 23:
3503 {
3504 Lexeme prevMatch = token.match;
3505 token.match = lexeme;
3506 int tokenId = GetTokenId(12);
3507 if (tokenId == CONTINUE_TOKEN)
3508 {
3509 token.id = tokenId;
3510 return -1;
3511 }
3512 else if (tokenId != INVALID_TOKEN)
3513 {
3514 token.id = tokenId;
3515 }
3516 else
3517 {
3518 token.match = prevMatch;
3519 }
3520 switch (i)
3521 {
3522 case 2:
3523 case 3:
3524 case 5:
3525 case 6:
3526 case 7:
3527 case 8:
3528 case 9:
3529 case 10:
3530 case 11:
3531 case 12:
3532 case 13:
3533 case 14:
3534 case 15:
3535 case 16:
3536 case 17:
3537 case 18:
3538 case 19:
3539 case 20:
3540 case 21:
3541 case 22:
3542 case 23:
3543 case 24:
3544 case 25:
3545 case 26:
3546 case 27:
3547 case 28:
3548 case 29:
3549 case 30:
3550 case 31:
3551 case 32:
3552 case 33:
3553 case 34:
3554 case 35:
3555 case 36:
3556 case 37:
3557 case 38:
3558 case 39:
3559 case 41:
3560 case 42:
3561 case 43:
3562 case 44:
3563 case 45:
3564 case 46:
3565 case 47:
3566 case 48:
3567 case 49:
3568 case 50:
3569 case 51:
3570 case 52:
3571 case 53:
3572 case 54:
3573 case 55:
3574 {
3575 return 7;
3576 }
3577 case 0:
3578 {
3579 return 39;
3580 }
3581 case 1:
3582 {
3583 return 40;
3584 }
3585 case 4:
3586 {
3587 return 41;
3588 }
3589 case 40:
3590 {
3591 return 63;
3592 }
3593 default:
3594 {
3595 return -1;
3596 }
3597 }
3598 }
3599 case 63:
3600 {
3601 Lexeme prevMatch = token.match;
3602 token.match = lexeme;
3603 int tokenId = GetTokenId(30);
3604 if (tokenId == CONTINUE_TOKEN)
3605 {
3606 token.id = tokenId;
3607 return -1;
3608 }
3609 else if (tokenId != INVALID_TOKEN)
3610 {
3611 token.id = tokenId;
3612 }
3613 else
3614 {
3615 token.match = prevMatch;
3616 }
3617 switch (i)
3618 {
3619 case 2:
3620 case 3:
3621 case 5:
3622 case 6:
3623 case 7:
3624 case 8:
3625 case 9:
3626 case 10:
3627 case 11:
3628 case 12:
3629 case 13:
3630 case 14:
3631 case 15:
3632 case 16:
3633 case 17:
3634 case 18:
3635 case 19:
3636 case 20:
3637 case 21:
3638 case 22:
3639 case 23:
3640 case 24:
3641 case 25:
3642 case 26:
3643 case 27:
3644 case 28:
3645 case 29:
3646 case 30:
3647 case 31:
3648 case 32:
3649 case 33:
3650 case 34:
3651 case 35:
3652 case 36:
3653 case 37:
3654 case 38:
3655 case 39:
3656 case 40:
3657 case 41:
3658 case 42:
3659 case 43:
3660 case 44:
3661 case 45:
3662 case 46:
3663 case 47:
3664 case 48:
3665 case 49:
3666 case 50:
3667 case 51:
3668 case 52:
3669 case 53:
3670 case 54:
3671 case 55:
3672 {
3673 return 7;
3674 }
3675 case 0:
3676 {
3677 return 39;
3678 }
3679 case 1:
3680 {
3681 return 40;
3682 }
3683 case 4:
3684 {
3685 return 41;
3686 }
3687 default:
3688 {
3689 return -1;
3690 }
3691 }
3692 }
3693 case 22:
3694 {
3695 Lexeme prevMatch = token.match;
3696 token.match = lexeme;
3697 int tokenId = GetTokenId(11);
3698 if (tokenId == CONTINUE_TOKEN)
3699 {
3700 token.id = tokenId;
3701 return -1;
3702 }
3703 else if (tokenId != INVALID_TOKEN)
3704 {
3705 token.id = tokenId;
3706 }
3707 else
3708 {
3709 token.match = prevMatch;
3710 }
3711 switch (i)
3712 {
3713 case 2:
3714 case 3:
3715 case 5:
3716 case 6:
3717 case 7:
3718 case 8:
3719 case 9:
3720 case 10:
3721 case 11:
3722 case 12:
3723 case 13:
3724 case 14:
3725 case 15:
3726 case 16:
3727 case 17:
3728 case 18:
3729 case 19:
3730 case 20:
3731 case 21:
3732 case 22:
3733 case 23:
3734 case 24:
3735 case 25:
3736 case 26:
3737 case 27:
3738 case 28:
3739 case 29:
3740 case 30:
3741 case 31:
3742 case 32:
3743 case 33:
3744 case 34:
3745 case 35:
3746 case 36:
3747 case 37:
3748 case 38:
3749 case 39:
3750 case 40:
3751 case 41:
3752 case 42:
3753 case 43:
3754 case 44:
3755 case 45:
3756 case 46:
3757 case 47:
3758 case 48:
3759 case 49:
3760 case 50:
3761 case 51:
3762 case 52:
3763 case 53:
3764 case 54:
3765 case 55:
3766 {
3767 return 7;
3768 }
3769 case 0:
3770 {
3771 return 39;
3772 }
3773 case 1:
3774 {
3775 return 40;
3776 }
3777 case 4:
3778 {
3779 return 41;
3780 }
3781 default:
3782 {
3783 return -1;
3784 }
3785 }
3786 }
3787 case 21:
3788 {
3789 Lexeme prevMatch = token.match;
3790 token.match = lexeme;
3791 int tokenId = GetTokenId(24);
3792 if (tokenId == CONTINUE_TOKEN)
3793 {
3794 token.id = tokenId;
3795 return -1;
3796 }
3797 else if (tokenId != INVALID_TOKEN)
3798 {
3799 token.id = tokenId;
3800 }
3801 else
3802 {
3803 token.match = prevMatch;
3804 }
3805 switch (i)
3806 {
3807 case 2:
3808 case 3:
3809 case 5:
3810 case 6:
3811 case 7:
3812 case 8:
3813 case 9:
3814 case 10:
3815 case 11:
3816 case 12:
3817 case 13:
3818 case 14:
3819 case 15:
3820 case 16:
3821 case 17:
3822 case 18:
3823 case 19:
3824 case 20:
3825 case 21:
3826 case 22:
3827 case 23:
3828 case 24:
3829 case 25:
3830 case 26:
3831 case 27:
3832 case 28:
3833 case 29:
3834 case 30:
3835 case 31:
3836 case 32:
3837 case 33:
3838 case 34:
3839 case 35:
3840 case 36:
3841 case 37:
3842 case 39:
3843 case 40:
3844 case 41:
3845 case 42:
3846 case 43:
3847 case 44:
3848 case 45:
3849 case 46:
3850 case 47:
3851 case 48:
3852 case 49:
3853 case 50:
3854 case 51:
3855 case 52:
3856 case 53:
3857 case 54:
3858 case 55:
3859 {
3860 return 7;
3861 }
3862 case 0:
3863 {
3864 return 39;
3865 }
3866 case 1:
3867 {
3868 return 40;
3869 }
3870 case 4:
3871 {
3872 return 41;
3873 }
3874 case 38:
3875 {
3876 return 64;
3877 }
3878 default:
3879 {
3880 return -1;
3881 }
3882 }
3883 }
3884 case 64:
3885 {
3886 Lexeme prevMatch = token.match;
3887 token.match = lexeme;
3888 int tokenId = GetTokenId(10);
3889 if (tokenId == CONTINUE_TOKEN)
3890 {
3891 token.id = tokenId;
3892 return -1;
3893 }
3894 else if (tokenId != INVALID_TOKEN)
3895 {
3896 token.id = tokenId;
3897 }
3898 else
3899 {
3900 token.match = prevMatch;
3901 }
3902 switch (i)
3903 {
3904 case 2:
3905 case 3:
3906 case 5:
3907 case 6:
3908 case 7:
3909 case 8:
3910 case 9:
3911 case 10:
3912 case 11:
3913 case 12:
3914 case 13:
3915 case 14:
3916 case 15:
3917 case 16:
3918 case 17:
3919 case 18:
3920 case 19:
3921 case 20:
3922 case 21:
3923 case 22:
3924 case 23:
3925 case 24:
3926 case 25:
3927 case 26:
3928 case 27:
3929 case 28:
3930 case 29:
3931 case 30:
3932 case 31:
3933 case 32:
3934 case 33:
3935 case 34:
3936 case 35:
3937 case 36:
3938 case 37:
3939 case 38:
3940 case 39:
3941 case 40:
3942 case 41:
3943 case 42:
3944 case 43:
3945 case 44:
3946 case 45:
3947 case 46:
3948 case 47:
3949 case 48:
3950 case 49:
3951 case 50:
3952 case 51:
3953 case 52:
3954 case 53:
3955 case 54:
3956 case 55:
3957 {
3958 return 7;
3959 }
3960 case 0:
3961 {
3962 return 39;
3963 }
3964 case 1:
3965 {
3966 return 40;
3967 }
3968 case 4:
3969 {
3970 return 41;
3971 }
3972 default:
3973 {
3974 return -1;
3975 }
3976 }
3977 }
3978 case 20:
3979 {
3980 switch (i)
3981 {
3982 case 0:
3983 {
3984 return 1;
3985 }
3986 case 1:
3987 {
3988 return 2;
3989 }
3990 case 2:
3991 {
3992 return 3;
3993 }
3994 case 3:
3995 {
3996 return 4;
3997 }
3998 case 4:
3999 {
4000 return 5;
4001 }
4002 case 5:
4003 case 14:
4004 case 18:
4005 case 19:
4006 case 20:
4007 case 21:
4008 case 22:
4009 case 24:
4010 case 28:
4011 case 29:
4012 case 30:
4013 case 31:
4014 case 32:
4015 case 33:
4016 {
4017 return 6;
4018 }
4019 case 6:
4020 case 7:
4021 case 8:
4022 {
4023 return 7;
4024 }
4025 case 9:
4026 {
4027 return 8;
4028 }
4029 case 10:
4030 {
4031 return 9;
4032 }
4033 case 11:
4034 {
4035 return 10;
4036 }
4037 case 12:
4038 {
4039 return 11;
4040 }
4041 case 13:
4042 {
4043 return 12;
4044 }
4045 case 15:
4046 {
4047 return 13;
4048 }
4049 case 16:
4050 {
4051 return 14;
4052 }
4053 case 17:
4054 {
4055 return 15;
4056 }
4057 case 23:
4058 {
4059 return 16;
4060 }
4061 case 25:
4062 case 26:
4063 case 27:
4064 {
4065 return 17;
4066 }
4067 case 34:
4068 case 35:
4069 {
4070 return 18;
4071 }
4072 case 36:
4073 {
4074 return 19;
4075 }
4076 case 38:
4077 {
4078 return 21;
4079 }
4080 case 39:
4081 {
4082 return 22;
4083 }
4084 case 40:
4085 {
4086 return 23;
4087 }
4088 case 41:
4089 {
4090 return 24;
4091 }
4092 case 42:
4093 {
4094 return 25;
4095 }
4096 case 43:
4097 {
4098 return 26;
4099 }
4100 case 44:
4101 {
4102 return 27;
4103 }
4104 case 45:
4105 {
4106 return 28;
4107 }
4108 case 46:
4109 {
4110 return 29;
4111 }
4112 case 47:
4113 {
4114 return 30;
4115 }
4116 case 48:
4117 {
4118 return 31;
4119 }
4120 case 49:
4121 {
4122 return 32;
4123 }
4124 case 50:
4125 {
4126 return 33;
4127 }
4128 case 51:
4129 {
4130 return 34;
4131 }
4132 case 52:
4133 {
4134 return 35;
4135 }
4136 case 53:
4137 {
4138 return 36;
4139 }
4140 case 54:
4141 {
4142 return 37;
4143 }
4144 case 55:
4145 {
4146 return 38;
4147 }
4148 case 37:
4149 {
4150 return 65;
4151 }
4152 default:
4153 {
4154 return -1;
4155 }
4156 }
4157 }
4158 case 65:
4159 {
4160 switch (i)
4161 {
4162 case 0:
4163 {
4164 return 1;
4165 }
4166 case 1:
4167 {
4168 return 2;
4169 }
4170 case 2:
4171 {
4172 return 3;
4173 }
4174 case 3:
4175 case 5:
4176 case 6:
4177 case 7:
4178 case 8:
4179 case 10:
4180 case 12:
4181 case 13:
4182 case 14:
4183 case 18:
4184 case 19:
4185 case 20:
4186 case 21:
4187 case 22:
4188 case 24:
4189 case 28:
4190 case 29:
4191 case 30:
4192 case 31:
4193 case 32:
4194 case 33:
4195 case 38:
4196 case 39:
4197 case 40:
4198 case 41:
4199 case 42:
4200 case 43:
4201 case 44:
4202 case 45:
4203 case 46:
4204 case 47:
4205 case 48:
4206 case 49:
4207 case 50:
4208 case 51:
4209 case 52:
4210 case 53:
4211 case 54:
4212 case 55:
4213 {
4214 return 7;
4215 }
4216 case 9:
4217 {
4218 return 8;
4219 }
4220 case 25:
4221 case 26:
4222 case 27:
4223 {
4224 return 17;
4225 }
4226 case 34:
4227 case 35:
4228 {
4229 return 18;
4230 }
4231 case 36:
4232 {
4233 return 19;
4234 }
4235 case 4:
4236 {
4237 return 41;
4238 }
4239 case 11:
4240 {
4241 return 66;
4242 }
4243 case 15:
4244 {
4245 return 67;
4246 }
4247 case 16:
4248 {
4249 return 68;
4250 }
4251 case 17:
4252 {
4253 return 69;
4254 }
4255 case 23:
4256 {
4257 return 70;
4258 }
4259 case 37:
4260 {
4261 return 71;
4262 }
4263 default:
4264 {
4265 return -1;
4266 }
4267 }
4268 }
4269 case 71:
4270 {
4271 switch (i)
4272 {
4273 case 1:
4274 {
4275 return 2;
4276 }
4277 case 2:
4278 {
4279 return 3;
4280 }
4281 case 3:
4282 case 5:
4283 case 6:
4284 case 7:
4285 case 8:
4286 case 9:
4287 case 10:
4288 case 11:
4289 case 12:
4290 case 13:
4291 case 14:
4292 case 18:
4293 case 19:
4294 case 20:
4295 case 21:
4296 case 22:
4297 case 24:
4298 case 28:
4299 case 29:
4300 case 30:
4301 case 31:
4302 case 32:
4303 case 33:
4304 case 36:
4305 case 38:
4306 case 39:
4307 case 40:
4308 case 41:
4309 case 42:
4310 case 43:
4311 case 44:
4312 case 45:
4313 case 46:
4314 case 47:
4315 case 48:
4316 case 49:
4317 case 50:
4318 case 51:
4319 case 52:
4320 case 53:
4321 case 54:
4322 case 55:
4323 {
4324 return 7;
4325 }
4326 case 25:
4327 case 26:
4328 case 27:
4329 {
4330 return 17;
4331 }
4332 case 4:
4333 {
4334 return 41;
4335 }
4336 case 15:
4337 {
4338 return 67;
4339 }
4340 case 16:
4341 {
4342 return 68;
4343 }
4344 case 17:
4345 {
4346 return 69;
4347 }
4348 case 23:
4349 {
4350 return 70;
4351 }
4352 case 0:
4353 {
4354 return 72;
4355 }
4356 case 34:
4357 case 35:
4358 {
4359 return 73;
4360 }
4361 case 37:
4362 {
4363 return 74;
4364 }
4365 default:
4366 {
4367 return -1;
4368 }
4369 }
4370 }
4371 case 74:
4372 {
4373 switch (i)
4374 {
4375 case 2:
4376 case 3:
4377 case 5:
4378 case 6:
4379 case 7:
4380 case 8:
4381 case 9:
4382 case 10:
4383 case 11:
4384 case 12:
4385 case 13:
4386 case 14:
4387 case 17:
4388 case 18:
4389 case 19:
4390 case 20:
4391 case 21:
4392 case 22:
4393 case 23:
4394 case 24:
4395 case 25:
4396 case 26:
4397 case 27:
4398 case 28:
4399 case 29:
4400 case 30:
4401 case 31:
4402 case 32:
4403 case 33:
4404 case 34:
4405 case 35:
4406 case 36:
4407 case 38:
4408 case 39:
4409 case 40:
4410 case 41:
4411 case 42:
4412 case 43:
4413 case 44:
4414 case 45:
4415 case 46:
4416 case 47:
4417 case 48:
4418 case 49:
4419 case 50:
4420 case 51:
4421 case 52:
4422 case 53:
4423 case 54:
4424 case 55:
4425 {
4426 return 7;
4427 }
4428 case 0:
4429 {
4430 return 39;
4431 }
4432 case 1:
4433 {
4434 return 40;
4435 }
4436 case 4:
4437 {
4438 return 41;
4439 }
4440 case 15:
4441 {
4442 return 67;
4443 }
4444 case 16:
4445 {
4446 return 68;
4447 }
4448 case 37:
4449 {
4450 return 75;
4451 }
4452 default:
4453 {
4454 return -1;
4455 }
4456 }
4457 }
4458 case 75:
4459 {
4460 switch (i)
4461 {
4462 case 2:
4463 case 3:
4464 case 5:
4465 case 6:
4466 case 7:
4467 case 8:
4468 case 9:
4469 case 10:
4470 case 11:
4471 case 12:
4472 case 13:
4473 case 14:
4474 case 16:
4475 case 17:
4476 case 18:
4477 case 19:
4478 case 20:
4479 case 21:
4480 case 22:
4481 case 23:
4482 case 24:
4483 case 25:
4484 case 26:
4485 case 27:
4486 case 28:
4487 case 29:
4488 case 30:
4489 case 31:
4490 case 32:
4491 case 33:
4492 case 34:
4493 case 35:
4494 case 36:
4495 case 37:
4496 case 38:
4497 case 39:
4498 case 40:
4499 case 41:
4500 case 42:
4501 case 43:
4502 case 44:
4503 case 45:
4504 case 46:
4505 case 47:
4506 case 48:
4507 case 49:
4508 case 50:
4509 case 51:
4510 case 52:
4511 case 53:
4512 case 54:
4513 case 55:
4514 {
4515 return 7;
4516 }
4517 case 0:
4518 {
4519 return 39;
4520 }
4521 case 1:
4522 {
4523 return 40;
4524 }
4525 case 4:
4526 {
4527 return 41;
4528 }
4529 case 15:
4530 {
4531 return 67;
4532 }
4533 default:
4534 {
4535 return -1;
4536 }
4537 }
4538 }
4539 case 73:
4540 {
4541 switch (i)
4542 {
4543 case 2:
4544 case 3:
4545 case 5:
4546 case 6:
4547 case 7:
4548 case 8:
4549 case 9:
4550 case 10:
4551 case 11:
4552 case 12:
4553 case 13:
4554 case 14:
4555 case 15:
4556 case 16:
4557 case 17:
4558 case 18:
4559 case 19:
4560 case 20:
4561 case 21:
4562 case 22:
4563 case 23:
4564 case 24:
4565 case 25:
4566 case 26:
4567 case 27:
4568 case 28:
4569 case 29:
4570 case 30:
4571 case 31:
4572 case 32:
4573 case 33:
4574 case 38:
4575 case 39:
4576 case 40:
4577 case 41:
4578 case 42:
4579 case 43:
4580 case 44:
4581 case 45:
4582 case 46:
4583 case 47:
4584 case 48:
4585 case 49:
4586 case 50:
4587 case 51:
4588 case 52:
4589 case 53:
4590 case 54:
4591 case 55:
4592 {
4593 return 7;
4594 }
4595 case 36:
4596 {
4597 return 19;
4598 }
4599 case 0:
4600 {
4601 return 39;
4602 }
4603 case 1:
4604 {
4605 return 40;
4606 }
4607 case 4:
4608 {
4609 return 41;
4610 }
4611 case 34:
4612 case 35:
4613 {
4614 return 73;
4615 }
4616 case 37:
4617 {
4618 return 76;
4619 }
4620 default:
4621 {
4622 return -1;
4623 }
4624 }
4625 }
4626 case 76:
4627 {
4628 switch (i)
4629 {
4630 case 2:
4631 case 3:
4632 case 5:
4633 case 6:
4634 case 7:
4635 case 8:
4636 case 9:
4637 case 10:
4638 case 11:
4639 case 12:
4640 case 13:
4641 case 14:
4642 case 15:
4643 case 16:
4644 case 17:
4645 case 18:
4646 case 19:
4647 case 20:
4648 case 21:
4649 case 22:
4650 case 23:
4651 case 24:
4652 case 25:
4653 case 26:
4654 case 27:
4655 case 28:
4656 case 29:
4657 case 30:
4658 case 31:
4659 case 32:
4660 case 33:
4661 case 38:
4662 case 39:
4663 case 40:
4664 case 41:
4665 case 42:
4666 case 43:
4667 case 44:
4668 case 45:
4669 case 46:
4670 case 47:
4671 case 48:
4672 case 49:
4673 case 50:
4674 case 51:
4675 case 52:
4676 case 53:
4677 case 54:
4678 case 55:
4679 {
4680 return 7;
4681 }
4682 case 36:
4683 {
4684 return 19;
4685 }
4686 case 0:
4687 {
4688 return 39;
4689 }
4690 case 1:
4691 {
4692 return 40;
4693 }
4694 case 4:
4695 {
4696 return 41;
4697 }
4698 case 34:
4699 case 35:
4700 {
4701 return 73;
4702 }
4703 case 37:
4704 {
4705 return 77;
4706 }
4707 default:
4708 {
4709 return -1;
4710 }
4711 }
4712 }
4713 case 77:
4714 {
4715 switch (i)
4716 {
4717 case 2:
4718 case 3:
4719 case 5:
4720 case 6:
4721 case 7:
4722 case 8:
4723 case 9:
4724 case 10:
4725 case 11:
4726 case 12:
4727 case 13:
4728 case 14:
4729 case 15:
4730 case 16:
4731 case 17:
4732 case 18:
4733 case 19:
4734 case 20:
4735 case 21:
4736 case 22:
4737 case 23:
4738 case 24:
4739 case 25:
4740 case 26:
4741 case 27:
4742 case 28:
4743 case 29:
4744 case 30:
4745 case 31:
4746 case 32:
4747 case 33:
4748 case 38:
4749 case 39:
4750 case 40:
4751 case 41:
4752 case 42:
4753 case 43:
4754 case 44:
4755 case 45:
4756 case 46:
4757 case 47:
4758 case 48:
4759 case 49:
4760 case 50:
4761 case 51:
4762 case 52:
4763 case 53:
4764 case 54:
4765 case 55:
4766 {
4767 return 7;
4768 }
4769 case 36:
4770 {
4771 return 19;
4772 }
4773 case 0:
4774 {
4775 return 39;
4776 }
4777 case 1:
4778 {
4779 return 40;
4780 }
4781 case 4:
4782 {
4783 return 41;
4784 }
4785 case 34:
4786 case 35:
4787 {
4788 return 73;
4789 }
4790 case 37:
4791 {
4792 return 78;
4793 }
4794 default:
4795 {
4796 return -1;
4797 }
4798 }
4799 }
4800 case 78:
4801 {
4802 switch (i)
4803 {
4804 case 2:
4805 case 3:
4806 case 5:
4807 case 6:
4808 case 7:
4809 case 8:
4810 case 9:
4811 case 10:
4812 case 11:
4813 case 12:
4814 case 13:
4815 case 14:
4816 case 15:
4817 case 16:
4818 case 17:
4819 case 18:
4820 case 19:
4821 case 20:
4822 case 21:
4823 case 22:
4824 case 23:
4825 case 24:
4826 case 25:
4827 case 26:
4828 case 27:
4829 case 28:
4830 case 29:
4831 case 30:
4832 case 31:
4833 case 32:
4834 case 33:
4835 case 36:
4836 case 37:
4837 case 38:
4838 case 39:
4839 case 40:
4840 case 41:
4841 case 42:
4842 case 43:
4843 case 44:
4844 case 45:
4845 case 46:
4846 case 47:
4847 case 48:
4848 case 49:
4849 case 50:
4850 case 51:
4851 case 52:
4852 case 53:
4853 case 54:
4854 case 55:
4855 {
4856 return 7;
4857 }
4858 case 0:
4859 {
4860 return 39;
4861 }
4862 case 1:
4863 {
4864 return 40;
4865 }
4866 case 4:
4867 {
4868 return 41;
4869 }
4870 case 34:
4871 case 35:
4872 {
4873 return 73;
4874 }
4875 default:
4876 {
4877 return -1;
4878 }
4879 }
4880 }
4881 case 72:
4882 {
4883 Lexeme prevMatch = token.match;
4884 token.match = lexeme;
4885 int tokenId = GetTokenId(4);
4886 if (tokenId == CONTINUE_TOKEN)
4887 {
4888 token.id = tokenId;
4889 return -1;
4890 }
4891 else if (tokenId != INVALID_TOKEN)
4892 {
4893 token.id = tokenId;
4894 }
4895 else
4896 {
4897 token.match = prevMatch;
4898 }
4899 switch (i)
4900 {
4901 case 37:
4902 {
4903 return 46;
4904 }
4905 case 1:
4906 {
4907 return 79;
4908 }
4909 default:
4910 {
4911 return -1;
4912 }
4913 }
4914 }
4915 case 79:
4916 {
4917 Lexeme prevMatch = token.match;
4918 token.match = lexeme;
4919 int tokenId = GetTokenId(1);
4920 if (tokenId == CONTINUE_TOKEN)
4921 {
4922 token.id = tokenId;
4923 return -1;
4924 }
4925 else if (tokenId != INVALID_TOKEN)
4926 {
4927 token.id = tokenId;
4928 }
4929 else
4930 {
4931 token.match = prevMatch;
4932 }
4933 switch (i)
4934 {
4935 case 37:
4936 {
4937 return 80;
4938 }
4939 default:
4940 {
4941 return -1;
4942 }
4943 }
4944 }
4945 case 80:
4946 {
4947 Lexeme prevMatch = token.match;
4948 token.match = lexeme;
4949 int tokenId = GetTokenId(1);
4950 if (tokenId == CONTINUE_TOKEN)
4951 {
4952 token.id = tokenId;
4953 return -1;
4954 }
4955 else if (tokenId != INVALID_TOKEN)
4956 {
4957 token.id = tokenId;
4958 }
4959 else
4960 {
4961 token.match = prevMatch;
4962 }
4963 switch (i)
4964 {
4965 case 37:
4966 {
4967 return 81;
4968 }
4969 default:
4970 {
4971 return -1;
4972 }
4973 }
4974 }
4975 case 81:
4976 {
4977 Lexeme prevMatch = token.match;
4978 token.match = lexeme;
4979 int tokenId = GetTokenId(1);
4980 if (tokenId == CONTINUE_TOKEN)
4981 {
4982 token.id = tokenId;
4983 return -1;
4984 }
4985 else if (tokenId != INVALID_TOKEN)
4986 {
4987 token.id = tokenId;
4988 }
4989 else
4990 {
4991 token.match = prevMatch;
4992 }
4993 switch (i)
4994 {
4995 case 37:
4996 {
4997 return 47;
4998 }
4999 default:
5000 {
5001 return -1;
5002 }
5003 }
5004 }
5005 case 70:
5006 {
5007 switch (i)
5008 {
5009 case 3:
5010 case 5:
5011 case 6:
5012 case 7:
5013 case 8:
5014 case 9:
5015 case 10:
5016 case 11:
5017 case 12:
5018 case 13:
5019 case 14:
5020 case 15:
5021 case 16:
5022 case 17:
5023 case 18:
5024 case 19:
5025 case 20:
5026 case 21:
5027 case 22:
5028 case 23:
5029 case 24:
5030 case 25:
5031 case 26:
5032 case 27:
5033 case 28:
5034 case 29:
5035 case 30:
5036 case 31:
5037 case 32:
5038 case 33:
5039 case 34:
5040 case 35:
5041 case 36:
5042 case 37:
5043 case 38:
5044 case 39:
5045 case 40:
5046 case 41:
5047 case 42:
5048 case 43:
5049 case 44:
5050 case 45:
5051 case 46:
5052 case 47:
5053 case 48:
5054 case 49:
5055 case 50:
5056 case 51:
5057 case 52:
5058 case 53:
5059 case 54:
5060 case 55:
5061 {
5062 return 7;
5063 }
5064 case 0:
5065 {
5066 return 39;
5067 }
5068 case 1:
5069 {
5070 return 40;
5071 }
5072 case 4:
5073 {
5074 return 41;
5075 }
5076 case 2:
5077 {
5078 return 82;
5079 }
5080 default:
5081 {
5082 return -1;
5083 }
5084 }
5085 }
5086 case 82:
5087 {
5088 switch (i)
5089 {
5090 case 0:
5091 {
5092 return 39;
5093 }
5094 case 1:
5095 {
5096 return 40;
5097 }
5098 case 2:
5099 {
5100 return 83;
5101 }
5102 case 3:
5103 case 5:
5104 case 6:
5105 case 7:
5106 case 8:
5107 case 9:
5108 case 10:
5109 case 11:
5110 case 12:
5111 case 13:
5112 case 14:
5113 case 15:
5114 case 16:
5115 case 17:
5116 case 18:
5117 case 19:
5118 case 20:
5119 case 21:
5120 case 22:
5121 case 23:
5122 case 24:
5123 case 25:
5124 case 26:
5125 case 27:
5126 case 28:
5127 case 29:
5128 case 30:
5129 case 31:
5130 case 32:
5131 case 33:
5132 case 34:
5133 case 35:
5134 case 36:
5135 case 37:
5136 case 38:
5137 case 39:
5138 case 40:
5139 case 41:
5140 case 42:
5141 case 43:
5142 case 44:
5143 case 45:
5144 case 46:
5145 case 47:
5146 case 48:
5147 case 49:
5148 case 50:
5149 case 51:
5150 case 52:
5151 case 53:
5152 case 54:
5153 case 55:
5154 {
5155 return 84;
5156 }
5157 case 4:
5158 {
5159 return 85;
5160 }
5161 default:
5162 {
5163 return -1;
5164 }
5165 }
5166 }
5167 case 85:
5168 {
5169 switch (i)
5170 {
5171 case 0:
5172 {
5173 return 39;
5174 }
5175 case 1:
5176 {
5177 return 40;
5178 }
5179 case 4:
5180 {
5181 return 85;
5182 }
5183 case 2:
5184 {
5185 return 86;
5186 }
5187 case 3:
5188 {
5189 return 87;
5190 }
5191 case 5:
5192 case 6:
5193 case 7:
5194 case 8:
5195 case 9:
5196 case 10:
5197 case 11:
5198 case 12:
5199 case 13:
5200 case 14:
5201 case 15:
5202 case 16:
5203 case 17:
5204 case 18:
5205 case 19:
5206 case 20:
5207 case 21:
5208 case 22:
5209 case 23:
5210 case 24:
5211 case 25:
5212 case 26:
5213 case 27:
5214 case 28:
5215 case 29:
5216 case 30:
5217 case 31:
5218 case 32:
5219 case 33:
5220 case 34:
5221 case 35:
5222 case 36:
5223 case 37:
5224 case 38:
5225 case 39:
5226 case 40:
5227 case 41:
5228 case 42:
5229 case 43:
5230 case 44:
5231 case 45:
5232 case 46:
5233 case 47:
5234 case 48:
5235 case 49:
5236 case 50:
5237 case 51:
5238 case 52:
5239 case 53:
5240 case 54:
5241 case 55:
5242 {
5243 return 88;
5244 }
5245 default:
5246 {
5247 return -1;
5248 }
5249 }
5250 }
5251 case 88:
5252 {
5253 switch (i)
5254 {
5255 case 0:
5256 {
5257 return 39;
5258 }
5259 case 1:
5260 {
5261 return 40;
5262 }
5263 case 2:
5264 {
5265 return 83;
5266 }
5267 case 3:
5268 case 5:
5269 case 6:
5270 case 7:
5271 case 8:
5272 case 9:
5273 case 10:
5274 case 11:
5275 case 12:
5276 case 13:
5277 case 14:
5278 case 15:
5279 case 16:
5280 case 17:
5281 case 18:
5282 case 19:
5283 case 20:
5284 case 21:
5285 case 22:
5286 case 23:
5287 case 24:
5288 case 25:
5289 case 26:
5290 case 27:
5291 case 28:
5292 case 29:
5293 case 30:
5294 case 31:
5295 case 32:
5296 case 33:
5297 case 34:
5298 case 35:
5299 case 36:
5300 case 37:
5301 case 38:
5302 case 39:
5303 case 40:
5304 case 41:
5305 case 42:
5306 case 43:
5307 case 44:
5308 case 45:
5309 case 46:
5310 case 47:
5311 case 48:
5312 case 49:
5313 case 50:
5314 case 51:
5315 case 52:
5316 case 53:
5317 case 54:
5318 case 55:
5319 {
5320 return 84;
5321 }
5322 case 4:
5323 {
5324 return 85;
5325 }
5326 default:
5327 {
5328 return -1;
5329 }
5330 }
5331 }
5332 case 87:
5333 {
5334 Lexeme prevMatch = token.match;
5335 token.match = lexeme;
5336 int tokenId = GetTokenId(4);
5337 if (tokenId == CONTINUE_TOKEN)
5338 {
5339 token.id = tokenId;
5340 return -1;
5341 }
5342 else if (tokenId != INVALID_TOKEN)
5343 {
5344 token.id = tokenId;
5345 }
5346 else
5347 {
5348 token.match = prevMatch;
5349 }
5350 switch (i)
5351 {
5352 case 0:
5353 {
5354 return 39;
5355 }
5356 case 1:
5357 {
5358 return 40;
5359 }
5360 case 2:
5361 {
5362 return 83;
5363 }
5364 case 3:
5365 case 5:
5366 case 6:
5367 case 7:
5368 case 8:
5369 case 9:
5370 case 10:
5371 case 11:
5372 case 12:
5373 case 13:
5374 case 14:
5375 case 15:
5376 case 16:
5377 case 17:
5378 case 18:
5379 case 19:
5380 case 20:
5381 case 21:
5382 case 22:
5383 case 23:
5384 case 24:
5385 case 25:
5386 case 26:
5387 case 27:
5388 case 28:
5389 case 29:
5390 case 30:
5391 case 31:
5392 case 32:
5393 case 33:
5394 case 34:
5395 case 35:
5396 case 36:
5397 case 38:
5398 case 39:
5399 case 40:
5400 case 41:
5401 case 42:
5402 case 43:
5403 case 44:
5404 case 45:
5405 case 46:
5406 case 47:
5407 case 48:
5408 case 49:
5409 case 50:
5410 case 51:
5411 case 52:
5412 case 53:
5413 case 54:
5414 case 55:
5415 {
5416 return 84;
5417 }
5418 case 4:
5419 {
5420 return 85;
5421 }
5422 case 37:
5423 {
5424 return 89;
5425 }
5426 default:
5427 {
5428 return -1;
5429 }
5430 }
5431 }
5432 case 89:
5433 {
5434 Lexeme prevMatch = token.match;
5435 token.match = lexeme;
5436 int tokenId = GetTokenId(4);
5437 if (tokenId == CONTINUE_TOKEN)
5438 {
5439 token.id = tokenId;
5440 return -1;
5441 }
5442 else if (tokenId != INVALID_TOKEN)
5443 {
5444 token.id = tokenId;
5445 }
5446 else
5447 {
5448 token.match = prevMatch;
5449 }
5450 switch (i)
5451 {
5452 case 0:
5453 {
5454 return 39;
5455 }
5456 case 1:
5457 {
5458 return 40;
5459 }
5460 case 2:
5461 {
5462 return 83;
5463 }
5464 case 3:
5465 case 5:
5466 case 6:
5467 case 7:
5468 case 8:
5469 case 9:
5470 case 10:
5471 case 11:
5472 case 12:
5473 case 13:
5474 case 14:
5475 case 15:
5476 case 16:
5477 case 17:
5478 case 18:
5479 case 19:
5480 case 20:
5481 case 21:
5482 case 22:
5483 case 23:
5484 case 24:
5485 case 25:
5486 case 26:
5487 case 27:
5488 case 28:
5489 case 29:
5490 case 30:
5491 case 31:
5492 case 32:
5493 case 33:
5494 case 34:
5495 case 35:
5496 case 36:
5497 case 37:
5498 case 38:
5499 case 39:
5500 case 40:
5501 case 41:
5502 case 42:
5503 case 43:
5504 case 44:
5505 case 45:
5506 case 46:
5507 case 47:
5508 case 48:
5509 case 49:
5510 case 50:
5511 case 51:
5512 case 52:
5513 case 53:
5514 case 54:
5515 case 55:
5516 {
5517 return 84;
5518 }
5519 case 4:
5520 {
5521 return 85;
5522 }
5523 default:
5524 {
5525 return -1;
5526 }
5527 }
5528 }
5529 case 86:
5530 {
5531 Lexeme prevMatch = token.match;
5532 token.match = lexeme;
5533 int tokenId = GetTokenId(7);
5534 if (tokenId == CONTINUE_TOKEN)
5535 {
5536 token.id = tokenId;
5537 return -1;
5538 }
5539 else if (tokenId != INVALID_TOKEN)
5540 {
5541 token.id = tokenId;
5542 }
5543 else
5544 {
5545 token.match = prevMatch;
5546 }
5547 switch (i)
5548 {
5549 case 2:
5550 case 3:
5551 case 5:
5552 case 6:
5553 case 7:
5554 case 8:
5555 case 9:
5556 case 10:
5557 case 11:
5558 case 12:
5559 case 13:
5560 case 14:
5561 case 15:
5562 case 16:
5563 case 17:
5564 case 18:
5565 case 19:
5566 case 20:
5567 case 21:
5568 case 22:
5569 case 23:
5570 case 24:
5571 case 25:
5572 case 26:
5573 case 27:
5574 case 28:
5575 case 29:
5576 case 30:
5577 case 31:
5578 case 32:
5579 case 33:
5580 case 34:
5581 case 35:
5582 case 36:
5583 case 38:
5584 case 39:
5585 case 40:
5586 case 41:
5587 case 42:
5588 case 43:
5589 case 44:
5590 case 45:
5591 case 46:
5592 case 47:
5593 case 48:
5594 case 49:
5595 case 50:
5596 case 51:
5597 case 52:
5598 case 53:
5599 case 54:
5600 case 55:
5601 {
5602 return 7;
5603 }
5604 case 0:
5605 {
5606 return 39;
5607 }
5608 case 1:
5609 {
5610 return 40;
5611 }
5612 case 4:
5613 {
5614 return 41;
5615 }
5616 case 37:
5617 {
5618 return 90;
5619 }
5620 default:
5621 {
5622 return -1;
5623 }
5624 }
5625 }
5626 case 90:
5627 {
5628 Lexeme prevMatch = token.match;
5629 token.match = lexeme;
5630 int tokenId = GetTokenId(7);
5631 if (tokenId == CONTINUE_TOKEN)
5632 {
5633 token.id = tokenId;
5634 return -1;
5635 }
5636 else if (tokenId != INVALID_TOKEN)
5637 {
5638 token.id = tokenId;
5639 }
5640 else
5641 {
5642 token.match = prevMatch;
5643 }
5644 switch (i)
5645 {
5646 case 2:
5647 case 3:
5648 case 5:
5649 case 6:
5650 case 7:
5651 case 8:
5652 case 9:
5653 case 10:
5654 case 11:
5655 case 12:
5656 case 13:
5657 case 14:
5658 case 15:
5659 case 16:
5660 case 17:
5661 case 18:
5662 case 19:
5663 case 20:
5664 case 21:
5665 case 22:
5666 case 23:
5667 case 24:
5668 case 25:
5669 case 26:
5670 case 27:
5671 case 28:
5672 case 29:
5673 case 30:
5674 case 31:
5675 case 32:
5676 case 33:
5677 case 34:
5678 case 35:
5679 case 36:
5680 case 37:
5681 case 38:
5682 case 39:
5683 case 40:
5684 case 41:
5685 case 42:
5686 case 43:
5687 case 44:
5688 case 45:
5689 case 46:
5690 case 47:
5691 case 48:
5692 case 49:
5693 case 50:
5694 case 51:
5695 case 52:
5696 case 53:
5697 case 54:
5698 case 55:
5699 {
5700 return 7;
5701 }
5702 case 0:
5703 {
5704 return 39;
5705 }
5706 case 1:
5707 {
5708 return 40;
5709 }
5710 case 4:
5711 {
5712 return 41;
5713 }
5714 default:
5715 {
5716 return -1;
5717 }
5718 }
5719 }
5720 case 84:
5721 {
5722 switch (i)
5723 {
5724 case 0:
5725 {
5726 return 39;
5727 }
5728 case 1:
5729 {
5730 return 40;
5731 }
5732 case 2:
5733 {
5734 return 83;
5735 }
5736 case 3:
5737 case 5:
5738 case 6:
5739 case 7:
5740 case 8:
5741 case 9:
5742 case 10:
5743 case 11:
5744 case 12:
5745 case 13:
5746 case 14:
5747 case 15:
5748 case 16:
5749 case 17:
5750 case 18:
5751 case 19:
5752 case 20:
5753 case 21:
5754 case 22:
5755 case 23:
5756 case 24:
5757 case 25:
5758 case 26:
5759 case 27:
5760 case 28:
5761 case 29:
5762 case 30:
5763 case 31:
5764 case 32:
5765 case 33:
5766 case 34:
5767 case 35:
5768 case 36:
5769 case 37:
5770 case 38:
5771 case 39:
5772 case 40:
5773 case 41:
5774 case 42:
5775 case 43:
5776 case 44:
5777 case 45:
5778 case 46:
5779 case 47:
5780 case 48:
5781 case 49:
5782 case 50:
5783 case 51:
5784 case 52:
5785 case 53:
5786 case 54:
5787 case 55:
5788 {
5789 return 84;
5790 }
5791 case 4:
5792 {
5793 return 85;
5794 }
5795 default:
5796 {
5797 return -1;
5798 }
5799 }
5800 }
5801 case 83:
5802 {
5803 Lexeme prevMatch = token.match;
5804 token.match = lexeme;
5805 int tokenId = GetTokenId(7);
5806 if (tokenId == CONTINUE_TOKEN)
5807 {
5808 token.id = tokenId;
5809 return -1;
5810 }
5811 else if (tokenId != INVALID_TOKEN)
5812 {
5813 token.id = tokenId;
5814 }
5815 else
5816 {
5817 token.match = prevMatch;
5818 }
5819 switch (i)
5820 {
5821 case 2:
5822 case 3:
5823 case 5:
5824 case 6:
5825 case 7:
5826 case 8:
5827 case 9:
5828 case 10:
5829 case 11:
5830 case 12:
5831 case 13:
5832 case 14:
5833 case 15:
5834 case 16:
5835 case 17:
5836 case 18:
5837 case 19:
5838 case 20:
5839 case 21:
5840 case 22:
5841 case 23:
5842 case 24:
5843 case 25:
5844 case 26:
5845 case 27:
5846 case 28:
5847 case 29:
5848 case 30:
5849 case 31:
5850 case 32:
5851 case 33:
5852 case 34:
5853 case 35:
5854 case 36:
5855 case 38:
5856 case 39:
5857 case 40:
5858 case 41:
5859 case 42:
5860 case 43:
5861 case 44:
5862 case 45:
5863 case 46:
5864 case 47:
5865 case 48:
5866 case 49:
5867 case 50:
5868 case 51:
5869 case 52:
5870 case 53:
5871 case 54:
5872 case 55:
5873 {
5874 return 7;
5875 }
5876 case 0:
5877 {
5878 return 39;
5879 }
5880 case 1:
5881 {
5882 return 40;
5883 }
5884 case 4:
5885 {
5886 return 41;
5887 }
5888 case 37:
5889 {
5890 return 90;
5891 }
5892 default:
5893 {
5894 return -1;
5895 }
5896 }
5897 }
5898 case 69:
5899 {
5900 switch (i)
5901 {
5902 case 2:
5903 {
5904 return 3;
5905 }
5906 case 3:
5907 case 5:
5908 case 6:
5909 case 7:
5910 case 8:
5911 case 9:
5912 case 10:
5913 case 11:
5914 case 12:
5915 case 13:
5916 case 14:
5917 case 15:
5918 case 16:
5919 case 17:
5920 case 18:
5921 case 19:
5922 case 20:
5923 case 21:
5924 case 22:
5925 case 24:
5926 case 25:
5927 case 26:
5928 case 27:
5929 case 28:
5930 case 29:
5931 case 30:
5932 case 31:
5933 case 32:
5934 case 33:
5935 case 34:
5936 case 35:
5937 case 36:
5938 case 38:
5939 case 39:
5940 case 40:
5941 case 41:
5942 case 42:
5943 case 43:
5944 case 44:
5945 case 45:
5946 case 46:
5947 case 47:
5948 case 48:
5949 case 49:
5950 case 50:
5951 case 51:
5952 case 52:
5953 case 53:
5954 case 54:
5955 case 55:
5956 {
5957 return 7;
5958 }
5959 case 0:
5960 {
5961 return 39;
5962 }
5963 case 1:
5964 {
5965 return 40;
5966 }
5967 case 4:
5968 {
5969 return 41;
5970 }
5971 case 23:
5972 {
5973 return 70;
5974 }
5975 case 37:
5976 {
5977 return 91;
5978 }
5979 default:
5980 {
5981 return -1;
5982 }
5983 }
5984 }
5985 case 91:
5986 {
5987 switch (i)
5988 {
5989 case 2:
5990 {
5991 return 3;
5992 }
5993 case 3:
5994 case 5:
5995 case 6:
5996 case 7:
5997 case 8:
5998 case 9:
5999 case 10:
6000 case 11:
6001 case 12:
6002 case 13:
6003 case 14:
6004 case 15:
6005 case 16:
6006 case 17:
6007 case 18:
6008 case 19:
6009 case 20:
6010 case 21:
6011 case 22:
6012 case 24:
6013 case 25:
6014 case 26:
6015 case 27:
6016 case 28:
6017 case 29:
6018 case 30:
6019 case 31:
6020 case 32:
6021 case 33:
6022 case 34:
6023 case 35:
6024 case 36:
6025 case 37:
6026 case 38:
6027 case 39:
6028 case 40:
6029 case 41:
6030 case 42:
6031 case 43:
6032 case 44:
6033 case 45:
6034 case 46:
6035 case 47:
6036 case 48:
6037 case 49:
6038 case 50:
6039 case 51:
6040 case 52:
6041 case 53:
6042 case 54:
6043 case 55:
6044 {
6045 return 7;
6046 }
6047 case 0:
6048 {
6049 return 39;
6050 }
6051 case 1:
6052 {
6053 return 40;
6054 }
6055 case 4:
6056 {
6057 return 41;
6058 }
6059 case 23:
6060 {
6061 return 70;
6062 }
6063 default:
6064 {
6065 return -1;
6066 }
6067 }
6068 }
6069 case 68:
6070 {
6071 switch (i)
6072 {
6073 case 2:
6074 {
6075 return 3;
6076 }
6077 case 3:
6078 case 5:
6079 case 6:
6080 case 7:
6081 case 8:
6082 case 9:
6083 case 10:
6084 case 11:
6085 case 12:
6086 case 13:
6087 case 14:
6088 case 15:
6089 case 16:
6090 case 17:
6091 case 18:
6092 case 19:
6093 case 20:
6094 case 21:
6095 case 22:
6096 case 24:
6097 case 25:
6098 case 26:
6099 case 27:
6100 case 28:
6101 case 29:
6102 case 30:
6103 case 31:
6104 case 32:
6105 case 33:
6106 case 34:
6107 case 35:
6108 case 36:
6109 case 38:
6110 case 39:
6111 case 40:
6112 case 41:
6113 case 42:
6114 case 43:
6115 case 44:
6116 case 45:
6117 case 46:
6118 case 47:
6119 case 48:
6120 case 49:
6121 case 50:
6122 case 51:
6123 case 52:
6124 case 53:
6125 case 54:
6126 case 55:
6127 {
6128 return 7;
6129 }
6130 case 0:
6131 {
6132 return 39;
6133 }
6134 case 1:
6135 {
6136 return 40;
6137 }
6138 case 4:
6139 {
6140 return 41;
6141 }
6142 case 23:
6143 {
6144 return 70;
6145 }
6146 case 37:
6147 {
6148 return 92;
6149 }
6150 default:
6151 {
6152 return -1;
6153 }
6154 }
6155 }
6156 case 92:
6157 {
6158 switch (i)
6159 {
6160 case 2:
6161 {
6162 return 3;
6163 }
6164 case 3:
6165 case 5:
6166 case 6:
6167 case 7:
6168 case 8:
6169 case 9:
6170 case 10:
6171 case 11:
6172 case 12:
6173 case 13:
6174 case 14:
6175 case 15:
6176 case 16:
6177 case 17:
6178 case 18:
6179 case 19:
6180 case 20:
6181 case 21:
6182 case 22:
6183 case 24:
6184 case 25:
6185 case 26:
6186 case 27:
6187 case 28:
6188 case 29:
6189 case 30:
6190 case 31:
6191 case 32:
6192 case 33:
6193 case 34:
6194 case 35:
6195 case 36:
6196 case 38:
6197 case 39:
6198 case 40:
6199 case 41:
6200 case 42:
6201 case 43:
6202 case 44:
6203 case 45:
6204 case 46:
6205 case 47:
6206 case 48:
6207 case 49:
6208 case 50:
6209 case 51:
6210 case 52:
6211 case 53:
6212 case 54:
6213 case 55:
6214 {
6215 return 7;
6216 }
6217 case 0:
6218 {
6219 return 39;
6220 }
6221 case 1:
6222 {
6223 return 40;
6224 }
6225 case 4:
6226 {
6227 return 41;
6228 }
6229 case 23:
6230 {
6231 return 70;
6232 }
6233 case 37:
6234 {
6235 return 91;
6236 }
6237 default:
6238 {
6239 return -1;
6240 }
6241 }
6242 }
6243 case 67:
6244 {
6245 switch (i)
6246 {
6247 case 2:
6248 {
6249 return 3;
6250 }
6251 case 3:
6252 case 5:
6253 case 6:
6254 case 7:
6255 case 8:
6256 case 9:
6257 case 10:
6258 case 11:
6259 case 12:
6260 case 13:
6261 case 14:
6262 case 15:
6263 case 16:
6264 case 17:
6265 case 18:
6266 case 19:
6267 case 20:
6268 case 21:
6269 case 22:
6270 case 24:
6271 case 25:
6272 case 27:
6273 case 28:
6274 case 29:
6275 case 30:
6276 case 31:
6277 case 32:
6278 case 33:
6279 case 34:
6280 case 35:
6281 case 36:
6282 case 38:
6283 case 39:
6284 case 40:
6285 case 41:
6286 case 42:
6287 case 43:
6288 case 44:
6289 case 45:
6290 case 46:
6291 case 47:
6292 case 48:
6293 case 49:
6294 case 50:
6295 case 51:
6296 case 52:
6297 case 53:
6298 case 54:
6299 case 55:
6300 {
6301 return 7;
6302 }
6303 case 0:
6304 {
6305 return 39;
6306 }
6307 case 1:
6308 {
6309 return 40;
6310 }
6311 case 4:
6312 {
6313 return 41;
6314 }
6315 case 23:
6316 {
6317 return 70;
6318 }
6319 case 26:
6320 {
6321 return 93;
6322 }
6323 case 37:
6324 {
6325 return 94;
6326 }
6327 default:
6328 {
6329 return -1;
6330 }
6331 }
6332 }
6333 case 94:
6334 {
6335 switch (i)
6336 {
6337 case 2:
6338 {
6339 return 3;
6340 }
6341 case 3:
6342 case 5:
6343 case 6:
6344 case 7:
6345 case 8:
6346 case 9:
6347 case 10:
6348 case 11:
6349 case 12:
6350 case 13:
6351 case 14:
6352 case 15:
6353 case 16:
6354 case 17:
6355 case 18:
6356 case 19:
6357 case 20:
6358 case 21:
6359 case 22:
6360 case 24:
6361 case 25:
6362 case 26:
6363 case 27:
6364 case 28:
6365 case 29:
6366 case 30:
6367 case 31:
6368 case 32:
6369 case 33:
6370 case 34:
6371 case 35:
6372 case 36:
6373 case 38:
6374 case 39:
6375 case 40:
6376 case 41:
6377 case 42:
6378 case 43:
6379 case 44:
6380 case 45:
6381 case 46:
6382 case 47:
6383 case 48:
6384 case 49:
6385 case 50:
6386 case 51:
6387 case 52:
6388 case 53:
6389 case 54:
6390 case 55:
6391 {
6392 return 7;
6393 }
6394 case 0:
6395 {
6396 return 39;
6397 }
6398 case 1:
6399 {
6400 return 40;
6401 }
6402 case 4:
6403 {
6404 return 41;
6405 }
6406 case 23:
6407 {
6408 return 70;
6409 }
6410 case 37:
6411 {
6412 return 92;
6413 }
6414 default:
6415 {
6416 return -1;
6417 }
6418 }
6419 }
6420 case 93:
6421 {
6422 switch (i)
6423 {
6424 case 2:
6425 {
6426 return 3;
6427 }
6428 case 3:
6429 case 5:
6430 case 6:
6431 case 7:
6432 case 8:
6433 case 9:
6434 case 10:
6435 case 11:
6436 case 12:
6437 case 13:
6438 case 14:
6439 case 15:
6440 case 16:
6441 case 17:
6442 case 18:
6443 case 19:
6444 case 20:
6445 case 21:
6446 case 22:
6447 case 24:
6448 case 25:
6449 case 26:
6450 case 27:
6451 case 28:
6452 case 29:
6453 case 30:
6454 case 31:
6455 case 32:
6456 case 33:
6457 case 34:
6458 case 35:
6459 case 36:
6460 case 38:
6461 case 39:
6462 case 40:
6463 case 41:
6464 case 42:
6465 case 43:
6466 case 44:
6467 case 45:
6468 case 46:
6469 case 47:
6470 case 48:
6471 case 49:
6472 case 50:
6473 case 51:
6474 case 52:
6475 case 53:
6476 case 54:
6477 case 55:
6478 {
6479 return 7;
6480 }
6481 case 0:
6482 {
6483 return 39;
6484 }
6485 case 1:
6486 {
6487 return 40;
6488 }
6489 case 4:
6490 {
6491 return 41;
6492 }
6493 case 23:
6494 {
6495 return 70;
6496 }
6497 case 37:
6498 {
6499 return 94;
6500 }
6501 default:
6502 {
6503 return -1;
6504 }
6505 }
6506 }
6507 case 66:
6508 {
6509 switch (i)
6510 {
6511 case 2:
6512 case 3:
6513 case 5:
6514 case 6:
6515 case 7:
6516 case 8:
6517 case 9:
6518 case 10:
6519 case 11:
6520 case 12:
6521 case 13:
6522 case 14:
6523 case 15:
6524 case 16:
6525 case 17:
6526 case 18:
6527 case 19:
6528 case 20:
6529 case 21:
6530 case 22:
6531 case 23:
6532 case 24:
6533 case 28:
6534 case 29:
6535 case 30:
6536 case 31:
6537 case 32:
6538 case 33:
6539 case 34:
6540 case 35:
6541 case 36:
6542 case 38:
6543 case 39:
6544 case 40:
6545 case 41:
6546 case 42:
6547 case 43:
6548 case 44:
6549 case 45:
6550 case 46:
6551 case 47:
6552 case 48:
6553 case 49:
6554 case 50:
6555 case 51:
6556 case 52:
6557 case 53:
6558 case 54:
6559 case 55:
6560 {
6561 return 7;
6562 }
6563 case 0:
6564 {
6565 return 39;
6566 }
6567 case 1:
6568 {
6569 return 40;
6570 }
6571 case 4:
6572 {
6573 return 41;
6574 }
6575 case 25:
6576 case 26:
6577 case 27:
6578 {
6579 return 95;
6580 }
6581 case 37:
6582 {
6583 return 96;
6584 }
6585 default:
6586 {
6587 return -1;
6588 }
6589 }
6590 }
6591 case 96:
6592 {
6593 switch (i)
6594 {
6595 case 2:
6596 case 3:
6597 case 5:
6598 case 6:
6599 case 7:
6600 case 8:
6601 case 9:
6602 case 10:
6603 case 11:
6604 case 12:
6605 case 13:
6606 case 14:
6607 case 15:
6608 case 16:
6609 case 17:
6610 case 18:
6611 case 19:
6612 case 20:
6613 case 21:
6614 case 22:
6615 case 23:
6616 case 24:
6617 case 28:
6618 case 29:
6619 case 30:
6620 case 31:
6621 case 32:
6622 case 33:
6623 case 34:
6624 case 35:
6625 case 36:
6626 case 37:
6627 case 38:
6628 case 39:
6629 case 40:
6630 case 41:
6631 case 42:
6632 case 43:
6633 case 44:
6634 case 45:
6635 case 46:
6636 case 47:
6637 case 48:
6638 case 49:
6639 case 50:
6640 case 51:
6641 case 52:
6642 case 53:
6643 case 54:
6644 case 55:
6645 {
6646 return 7;
6647 }
6648 case 0:
6649 {
6650 return 39;
6651 }
6652 case 1:
6653 {
6654 return 40;
6655 }
6656 case 4:
6657 {
6658 return 41;
6659 }
6660 case 25:
6661 case 26:
6662 case 27:
6663 {
6664 return 95;
6665 }
6666 default:
6667 {
6668 return -1;
6669 }
6670 }
6671 }
6672 case 95:
6673 {
6674 Lexeme prevMatch = token.match;
6675 token.match = lexeme;
6676 int tokenId = GetTokenId(8);
6677 if (tokenId == CONTINUE_TOKEN)
6678 {
6679 token.id = tokenId;
6680 return -1;
6681 }
6682 else if (tokenId != INVALID_TOKEN)
6683 {
6684 token.id = tokenId;
6685 }
6686 else
6687 {
6688 token.match = prevMatch;
6689 }
6690 switch (i)
6691 {
6692 case 2:
6693 case 3:
6694 case 5:
6695 case 6:
6696 case 7:
6697 case 9:
6698 case 10:
6699 case 11:
6700 case 12:
6701 case 13:
6702 case 34:
6703 case 35:
6704 case 36:
6705 case 38:
6706 case 39:
6707 case 40:
6708 case 41:
6709 case 42:
6710 case 43:
6711 case 44:
6712 case 45:
6713 case 46:
6714 case 47:
6715 case 48:
6716 case 49:
6717 case 50:
6718 case 51:
6719 case 52:
6720 case 53:
6721 case 54:
6722 case 55:
6723 {
6724 return 7;
6725 }
6726 case 0:
6727 {
6728 return 39;
6729 }
6730 case 1:
6731 {
6732 return 40;
6733 }
6734 case 4:
6735 {
6736 return 41;
6737 }
6738 case 25:
6739 case 26:
6740 case 27:
6741 {
6742 return 95;
6743 }
6744 case 8:
6745 {
6746 return 97;
6747 }
6748 case 14:
6749 case 15:
6750 case 16:
6751 case 17:
6752 case 18:
6753 case 19:
6754 case 20:
6755 case 21:
6756 case 22:
6757 case 23:
6758 case 24:
6759 case 28:
6760 case 29:
6761 case 30:
6762 case 31:
6763 {
6764 return 98;
6765 }
6766 case 32:
6767 case 33:
6768 {
6769 return 99;
6770 }
6771 case 37:
6772 {
6773 return 100;
6774 }
6775 default:
6776 {
6777 return -1;
6778 }
6779 }
6780 }
6781 case 100:
6782 {
6783 Lexeme prevMatch = token.match;
6784 token.match = lexeme;
6785 int tokenId = GetTokenId(8);
6786 if (tokenId == CONTINUE_TOKEN)
6787 {
6788 token.id = tokenId;
6789 return -1;
6790 }
6791 else if (tokenId != INVALID_TOKEN)
6792 {
6793 token.id = tokenId;
6794 }
6795 else
6796 {
6797 token.match = prevMatch;
6798 }
6799 switch (i)
6800 {
6801 case 2:
6802 case 3:
6803 case 5:
6804 case 6:
6805 case 7:
6806 case 9:
6807 case 10:
6808 case 11:
6809 case 12:
6810 case 13:
6811 case 34:
6812 case 35:
6813 case 36:
6814 case 38:
6815 case 39:
6816 case 40:
6817 case 41:
6818 case 42:
6819 case 43:
6820 case 44:
6821 case 45:
6822 case 46:
6823 case 47:
6824 case 48:
6825 case 49:
6826 case 50:
6827 case 51:
6828 case 52:
6829 case 53:
6830 case 54:
6831 case 55:
6832 {
6833 return 7;
6834 }
6835 case 0:
6836 {
6837 return 39;
6838 }
6839 case 1:
6840 {
6841 return 40;
6842 }
6843 case 4:
6844 {
6845 return 41;
6846 }
6847 case 25:
6848 case 26:
6849 case 27:
6850 {
6851 return 95;
6852 }
6853 case 8:
6854 {
6855 return 97;
6856 }
6857 case 14:
6858 case 15:
6859 case 16:
6860 case 17:
6861 case 18:
6862 case 19:
6863 case 20:
6864 case 21:
6865 case 22:
6866 case 23:
6867 case 24:
6868 case 28:
6869 case 29:
6870 case 30:
6871 case 31:
6872 {
6873 return 98;
6874 }
6875 case 32:
6876 case 33:
6877 {
6878 return 99;
6879 }
6880 case 37:
6881 {
6882 return 101;
6883 }
6884 default:
6885 {
6886 return -1;
6887 }
6888 }
6889 }
6890 case 101:
6891 {
6892 Lexeme prevMatch = token.match;
6893 token.match = lexeme;
6894 int tokenId = GetTokenId(8);
6895 if (tokenId == CONTINUE_TOKEN)
6896 {
6897 token.id = tokenId;
6898 return -1;
6899 }
6900 else if (tokenId != INVALID_TOKEN)
6901 {
6902 token.id = tokenId;
6903 }
6904 else
6905 {
6906 token.match = prevMatch;
6907 }
6908 switch (i)
6909 {
6910 case 2:
6911 case 3:
6912 case 5:
6913 case 6:
6914 case 7:
6915 case 9:
6916 case 10:
6917 case 11:
6918 case 12:
6919 case 13:
6920 case 25:
6921 case 26:
6922 case 27:
6923 case 34:
6924 case 35:
6925 case 36:
6926 case 38:
6927 case 39:
6928 case 40:
6929 case 41:
6930 case 42:
6931 case 43:
6932 case 44:
6933 case 45:
6934 case 46:
6935 case 47:
6936 case 48:
6937 case 49:
6938 case 50:
6939 case 51:
6940 case 52:
6941 case 53:
6942 case 54:
6943 case 55:
6944 {
6945 return 7;
6946 }
6947 case 0:
6948 {
6949 return 39;
6950 }
6951 case 1:
6952 {
6953 return 40;
6954 }
6955 case 4:
6956 {
6957 return 41;
6958 }
6959 case 8:
6960 {
6961 return 97;
6962 }
6963 case 14:
6964 case 15:
6965 case 16:
6966 case 17:
6967 case 18:
6968 case 19:
6969 case 20:
6970 case 21:
6971 case 22:
6972 case 23:
6973 case 24:
6974 case 28:
6975 case 29:
6976 case 30:
6977 case 31:
6978 {
6979 return 98;
6980 }
6981 case 32:
6982 case 33:
6983 {
6984 return 99;
6985 }
6986 case 37:
6987 {
6988 return 102;
6989 }
6990 default:
6991 {
6992 return -1;
6993 }
6994 }
6995 }
6996 case 102:
6997 {
6998 Lexeme prevMatch = token.match;
6999 token.match = lexeme;
7000 int tokenId = GetTokenId(8);
7001 if (tokenId == CONTINUE_TOKEN)
7002 {
7003 token.id = tokenId;
7004 return -1;
7005 }
7006 else if (tokenId != INVALID_TOKEN)
7007 {
7008 token.id = tokenId;
7009 }
7010 else
7011 {
7012 token.match = prevMatch;
7013 }
7014 switch (i)
7015 {
7016 case 2:
7017 case 3:
7018 case 5:
7019 case 6:
7020 case 7:
7021 case 9:
7022 case 10:
7023 case 11:
7024 case 12:
7025 case 13:
7026 case 25:
7027 case 26:
7028 case 27:
7029 case 34:
7030 case 35:
7031 case 36:
7032 case 38:
7033 case 39:
7034 case 40:
7035 case 41:
7036 case 42:
7037 case 43:
7038 case 44:
7039 case 45:
7040 case 46:
7041 case 47:
7042 case 48:
7043 case 49:
7044 case 50:
7045 case 51:
7046 case 52:
7047 case 53:
7048 case 54:
7049 case 55:
7050 {
7051 return 7;
7052 }
7053 case 0:
7054 {
7055 return 39;
7056 }
7057 case 1:
7058 {
7059 return 40;
7060 }
7061 case 4:
7062 {
7063 return 41;
7064 }
7065 case 8:
7066 {
7067 return 97;
7068 }
7069 case 14:
7070 case 15:
7071 case 16:
7072 case 17:
7073 case 18:
7074 case 19:
7075 case 20:
7076 case 21:
7077 case 22:
7078 case 23:
7079 case 24:
7080 case 28:
7081 case 29:
7082 case 30:
7083 case 31:
7084 {
7085 return 98;
7086 }
7087 case 32:
7088 case 33:
7089 {
7090 return 99;
7091 }
7092 case 37:
7093 {
7094 return 103;
7095 }
7096 default:
7097 {
7098 return -1;
7099 }
7100 }
7101 }
7102 case 103:
7103 {
7104 switch (i)
7105 {
7106 case 2:
7107 case 3:
7108 case 5:
7109 case 6:
7110 case 7:
7111 case 9:
7112 case 10:
7113 case 11:
7114 case 12:
7115 case 13:
7116 case 25:
7117 case 26:
7118 case 27:
7119 case 34:
7120 case 35:
7121 case 36:
7122 case 38:
7123 case 39:
7124 case 40:
7125 case 41:
7126 case 42:
7127 case 43:
7128 case 44:
7129 case 45:
7130 case 46:
7131 case 47:
7132 case 48:
7133 case 49:
7134 case 50:
7135 case 51:
7136 case 52:
7137 case 53:
7138 case 54:
7139 case 55:
7140 {
7141 return 7;
7142 }
7143 case 0:
7144 {
7145 return 39;
7146 }
7147 case 1:
7148 {
7149 return 40;
7150 }
7151 case 4:
7152 {
7153 return 41;
7154 }
7155 case 8:
7156 {
7157 return 97;
7158 }
7159 case 14:
7160 case 15:
7161 case 16:
7162 case 17:
7163 case 18:
7164 case 19:
7165 case 20:
7166 case 21:
7167 case 22:
7168 case 23:
7169 case 24:
7170 case 28:
7171 case 29:
7172 case 30:
7173 case 31:
7174 {
7175 return 98;
7176 }
7177 case 32:
7178 case 33:
7179 {
7180 return 99;
7181 }
7182 case 37:
7183 {
7184 return 104;
7185 }
7186 default:
7187 {
7188 return -1;
7189 }
7190 }
7191 }
7192 case 104:
7193 {
7194 switch (i)
7195 {
7196 case 2:
7197 case 3:
7198 case 5:
7199 case 6:
7200 case 7:
7201 case 9:
7202 case 10:
7203 case 11:
7204 case 12:
7205 case 13:
7206 case 25:
7207 case 26:
7208 case 27:
7209 case 34:
7210 case 35:
7211 case 36:
7212 case 38:
7213 case 39:
7214 case 40:
7215 case 41:
7216 case 42:
7217 case 43:
7218 case 44:
7219 case 45:
7220 case 46:
7221 case 47:
7222 case 48:
7223 case 49:
7224 case 50:
7225 case 51:
7226 case 52:
7227 case 53:
7228 case 54:
7229 case 55:
7230 {
7231 return 7;
7232 }
7233 case 0:
7234 {
7235 return 39;
7236 }
7237 case 1:
7238 {
7239 return 40;
7240 }
7241 case 4:
7242 {
7243 return 41;
7244 }
7245 case 8:
7246 {
7247 return 97;
7248 }
7249 case 14:
7250 case 15:
7251 case 16:
7252 case 17:
7253 case 18:
7254 case 19:
7255 case 20:
7256 case 21:
7257 case 22:
7258 case 23:
7259 case 24:
7260 case 28:
7261 case 29:
7262 case 30:
7263 case 31:
7264 case 32:
7265 case 33:
7266 {
7267 return 98;
7268 }
7269 case 37:
7270 {
7271 return 105;
7272 }
7273 default:
7274 {
7275 return -1;
7276 }
7277 }
7278 }
7279 case 105:
7280 {
7281 switch (i)
7282 {
7283 case 2:
7284 case 3:
7285 case 5:
7286 case 6:
7287 case 7:
7288 case 9:
7289 case 10:
7290 case 11:
7291 case 12:
7292 case 13:
7293 case 14:
7294 case 15:
7295 case 16:
7296 case 17:
7297 case 18:
7298 case 19:
7299 case 20:
7300 case 21:
7301 case 22:
7302 case 23:
7303 case 24:
7304 case 25:
7305 case 26:
7306 case 27:
7307 case 28:
7308 case 29:
7309 case 30:
7310 case 31:
7311 case 32:
7312 case 33:
7313 case 34:
7314 case 35:
7315 case 36:
7316 case 37:
7317 case 38:
7318 case 39:
7319 case 40:
7320 case 41:
7321 case 42:
7322 case 43:
7323 case 44:
7324 case 45:
7325 case 46:
7326 case 47:
7327 case 48:
7328 case 49:
7329 case 50:
7330 case 51:
7331 case 52:
7332 case 53:
7333 case 54:
7334 case 55:
7335 {
7336 return 7;
7337 }
7338 case 0:
7339 {
7340 return 39;
7341 }
7342 case 1:
7343 {
7344 return 40;
7345 }
7346 case 4:
7347 {
7348 return 41;
7349 }
7350 case 8:
7351 {
7352 return 97;
7353 }
7354 default:
7355 {
7356 return -1;
7357 }
7358 }
7359 }
7360 case 99:
7361 {
7362 Lexeme prevMatch = token.match;
7363 token.match = lexeme;
7364 int tokenId = GetTokenId(8);
7365 if (tokenId == CONTINUE_TOKEN)
7366 {
7367 token.id = tokenId;
7368 return -1;
7369 }
7370 else if (tokenId != INVALID_TOKEN)
7371 {
7372 token.id = tokenId;
7373 }
7374 else
7375 {
7376 token.match = prevMatch;
7377 }
7378 switch (i)
7379 {
7380 case 2:
7381 case 3:
7382 case 5:
7383 case 6:
7384 case 7:
7385 case 9:
7386 case 10:
7387 case 11:
7388 case 25:
7389 case 26:
7390 case 27:
7391 case 34:
7392 case 35:
7393 case 36:
7394 case 38:
7395 case 39:
7396 case 40:
7397 case 41:
7398 case 42:
7399 case 43:
7400 case 44:
7401 case 45:
7402 case 46:
7403 case 47:
7404 case 48:
7405 case 49:
7406 case 50:
7407 case 51:
7408 case 52:
7409 case 53:
7410 case 54:
7411 case 55:
7412 {
7413 return 7;
7414 }
7415 case 0:
7416 {
7417 return 39;
7418 }
7419 case 1:
7420 {
7421 return 40;
7422 }
7423 case 4:
7424 {
7425 return 41;
7426 }
7427 case 8:
7428 {
7429 return 97;
7430 }
7431 case 14:
7432 case 15:
7433 case 16:
7434 case 17:
7435 case 18:
7436 case 19:
7437 case 20:
7438 case 21:
7439 case 22:
7440 case 23:
7441 case 24:
7442 case 28:
7443 case 29:
7444 case 30:
7445 case 31:
7446 {
7447 return 98;
7448 }
7449 case 32:
7450 case 33:
7451 {
7452 return 99;
7453 }
7454 case 12:
7455 {
7456 return 106;
7457 }
7458 case 13:
7459 {
7460 return 107;
7461 }
7462 case 37:
7463 {
7464 return 108;
7465 }
7466 default:
7467 {
7468 return -1;
7469 }
7470 }
7471 }
7472 case 108:
7473 {
7474 Lexeme prevMatch = token.match;
7475 token.match = lexeme;
7476 int tokenId = GetTokenId(8);
7477 if (tokenId == CONTINUE_TOKEN)
7478 {
7479 token.id = tokenId;
7480 return -1;
7481 }
7482 else if (tokenId != INVALID_TOKEN)
7483 {
7484 token.id = tokenId;
7485 }
7486 else
7487 {
7488 token.match = prevMatch;
7489 }
7490 switch (i)
7491 {
7492 case 2:
7493 case 3:
7494 case 5:
7495 case 6:
7496 case 7:
7497 case 9:
7498 case 10:
7499 case 11:
7500 case 25:
7501 case 26:
7502 case 27:
7503 case 34:
7504 case 35:
7505 case 36:
7506 case 38:
7507 case 39:
7508 case 40:
7509 case 41:
7510 case 42:
7511 case 43:
7512 case 44:
7513 case 45:
7514 case 46:
7515 case 47:
7516 case 48:
7517 case 49:
7518 case 50:
7519 case 51:
7520 case 52:
7521 case 53:
7522 case 54:
7523 case 55:
7524 {
7525 return 7;
7526 }
7527 case 0:
7528 {
7529 return 39;
7530 }
7531 case 1:
7532 {
7533 return 40;
7534 }
7535 case 4:
7536 {
7537 return 41;
7538 }
7539 case 8:
7540 {
7541 return 97;
7542 }
7543 case 14:
7544 case 15:
7545 case 16:
7546 case 17:
7547 case 18:
7548 case 19:
7549 case 20:
7550 case 21:
7551 case 22:
7552 case 23:
7553 case 24:
7554 case 28:
7555 case 29:
7556 case 30:
7557 case 31:
7558 {
7559 return 98;
7560 }
7561 case 32:
7562 case 33:
7563 {
7564 return 99;
7565 }
7566 case 12:
7567 {
7568 return 106;
7569 }
7570 case 13:
7571 {
7572 return 107;
7573 }
7574 case 37:
7575 {
7576 return 109;
7577 }
7578 default:
7579 {
7580 return -1;
7581 }
7582 }
7583 }
7584 case 109:
7585 {
7586 Lexeme prevMatch = token.match;
7587 token.match = lexeme;
7588 int tokenId = GetTokenId(8);
7589 if (tokenId == CONTINUE_TOKEN)
7590 {
7591 token.id = tokenId;
7592 return -1;
7593 }
7594 else if (tokenId != INVALID_TOKEN)
7595 {
7596 token.id = tokenId;
7597 }
7598 else
7599 {
7600 token.match = prevMatch;
7601 }
7602 switch (i)
7603 {
7604 case 2:
7605 case 3:
7606 case 5:
7607 case 6:
7608 case 7:
7609 case 9:
7610 case 10:
7611 case 11:
7612 case 12:
7613 case 13:
7614 case 25:
7615 case 26:
7616 case 27:
7617 case 34:
7618 case 35:
7619 case 36:
7620 case 38:
7621 case 39:
7622 case 40:
7623 case 41:
7624 case 42:
7625 case 43:
7626 case 44:
7627 case 45:
7628 case 46:
7629 case 47:
7630 case 48:
7631 case 49:
7632 case 50:
7633 case 51:
7634 case 52:
7635 case 53:
7636 case 54:
7637 case 55:
7638 {
7639 return 7;
7640 }
7641 case 0:
7642 {
7643 return 39;
7644 }
7645 case 1:
7646 {
7647 return 40;
7648 }
7649 case 4:
7650 {
7651 return 41;
7652 }
7653 case 8:
7654 {
7655 return 97;
7656 }
7657 case 14:
7658 case 15:
7659 case 16:
7660 case 17:
7661 case 18:
7662 case 19:
7663 case 20:
7664 case 21:
7665 case 22:
7666 case 23:
7667 case 24:
7668 case 28:
7669 case 29:
7670 case 30:
7671 case 31:
7672 {
7673 return 98;
7674 }
7675 case 32:
7676 case 33:
7677 {
7678 return 99;
7679 }
7680 case 37:
7681 {
7682 return 102;
7683 }
7684 default:
7685 {
7686 return -1;
7687 }
7688 }
7689 }
7690 case 107:
7691 {
7692 Lexeme prevMatch = token.match;
7693 token.match = lexeme;
7694 int tokenId = GetTokenId(8);
7695 if (tokenId == CONTINUE_TOKEN)
7696 {
7697 token.id = tokenId;
7698 return -1;
7699 }
7700 else if (tokenId != INVALID_TOKEN)
7701 {
7702 token.id = tokenId;
7703 }
7704 else
7705 {
7706 token.match = prevMatch;
7707 }
7708 switch (i)
7709 {
7710 case 2:
7711 case 3:
7712 case 5:
7713 case 6:
7714 case 7:
7715 case 9:
7716 case 10:
7717 case 11:
7718 case 12:
7719 case 13:
7720 case 25:
7721 case 26:
7722 case 27:
7723 case 34:
7724 case 35:
7725 case 36:
7726 case 38:
7727 case 39:
7728 case 40:
7729 case 41:
7730 case 42:
7731 case 43:
7732 case 44:
7733 case 45:
7734 case 46:
7735 case 47:
7736 case 48:
7737 case 49:
7738 case 50:
7739 case 51:
7740 case 52:
7741 case 53:
7742 case 54:
7743 case 55:
7744 {
7745 return 7;
7746 }
7747 case 0:
7748 {
7749 return 39;
7750 }
7751 case 1:
7752 {
7753 return 40;
7754 }
7755 case 4:
7756 {
7757 return 41;
7758 }
7759 case 8:
7760 {
7761 return 97;
7762 }
7763 case 14:
7764 case 15:
7765 case 16:
7766 case 17:
7767 case 18:
7768 case 19:
7769 case 20:
7770 case 21:
7771 case 22:
7772 case 23:
7773 case 24:
7774 case 28:
7775 case 29:
7776 case 30:
7777 case 31:
7778 {
7779 return 98;
7780 }
7781 case 32:
7782 case 33:
7783 {
7784 return 99;
7785 }
7786 case 37:
7787 {
7788 return 110;
7789 }
7790 default:
7791 {
7792 return -1;
7793 }
7794 }
7795 }
7796 case 110:
7797 {
7798 Lexeme prevMatch = token.match;
7799 token.match = lexeme;
7800 int tokenId = GetTokenId(8);
7801 if (tokenId == CONTINUE_TOKEN)
7802 {
7803 token.id = tokenId;
7804 return -1;
7805 }
7806 else if (tokenId != INVALID_TOKEN)
7807 {
7808 token.id = tokenId;
7809 }
7810 else
7811 {
7812 token.match = prevMatch;
7813 }
7814 switch (i)
7815 {
7816 case 2:
7817 case 3:
7818 case 5:
7819 case 6:
7820 case 7:
7821 case 9:
7822 case 10:
7823 case 11:
7824 case 12:
7825 case 13:
7826 case 25:
7827 case 26:
7828 case 27:
7829 case 34:
7830 case 35:
7831 case 36:
7832 case 38:
7833 case 39:
7834 case 40:
7835 case 41:
7836 case 42:
7837 case 43:
7838 case 44:
7839 case 45:
7840 case 46:
7841 case 47:
7842 case 48:
7843 case 49:
7844 case 50:
7845 case 51:
7846 case 52:
7847 case 53:
7848 case 54:
7849 case 55:
7850 {
7851 return 7;
7852 }
7853 case 0:
7854 {
7855 return 39;
7856 }
7857 case 1:
7858 {
7859 return 40;
7860 }
7861 case 4:
7862 {
7863 return 41;
7864 }
7865 case 8:
7866 {
7867 return 97;
7868 }
7869 case 14:
7870 case 15:
7871 case 16:
7872 case 17:
7873 case 18:
7874 case 19:
7875 case 20:
7876 case 21:
7877 case 22:
7878 case 23:
7879 case 24:
7880 case 28:
7881 case 29:
7882 case 30:
7883 case 31:
7884 {
7885 return 98;
7886 }
7887 case 32:
7888 case 33:
7889 {
7890 return 99;
7891 }
7892 case 37:
7893 {
7894 return 109;
7895 }
7896 default:
7897 {
7898 return -1;
7899 }
7900 }
7901 }
7902 case 106:
7903 {
7904 Lexeme prevMatch = token.match;
7905 token.match = lexeme;
7906 int tokenId = GetTokenId(8);
7907 if (tokenId == CONTINUE_TOKEN)
7908 {
7909 token.id = tokenId;
7910 return -1;
7911 }
7912 else if (tokenId != INVALID_TOKEN)
7913 {
7914 token.id = tokenId;
7915 }
7916 else
7917 {
7918 token.match = prevMatch;
7919 }
7920 switch (i)
7921 {
7922 case 2:
7923 case 3:
7924 case 5:
7925 case 6:
7926 case 7:
7927 case 9:
7928 case 10:
7929 case 11:
7930 case 12:
7931 case 13:
7932 case 25:
7933 case 26:
7934 case 27:
7935 case 34:
7936 case 35:
7937 case 36:
7938 case 38:
7939 case 39:
7940 case 40:
7941 case 41:
7942 case 42:
7943 case 43:
7944 case 44:
7945 case 45:
7946 case 46:
7947 case 47:
7948 case 48:
7949 case 49:
7950 case 50:
7951 case 51:
7952 case 52:
7953 case 53:
7954 case 54:
7955 case 55:
7956 {
7957 return 7;
7958 }
7959 case 0:
7960 {
7961 return 39;
7962 }
7963 case 1:
7964 {
7965 return 40;
7966 }
7967 case 4:
7968 {
7969 return 41;
7970 }
7971 case 8:
7972 {
7973 return 97;
7974 }
7975 case 14:
7976 case 15:
7977 case 16:
7978 case 17:
7979 case 18:
7980 case 19:
7981 case 20:
7982 case 21:
7983 case 22:
7984 case 23:
7985 case 24:
7986 case 28:
7987 case 29:
7988 case 30:
7989 case 31:
7990 {
7991 return 98;
7992 }
7993 case 32:
7994 case 33:
7995 {
7996 return 99;
7997 }
7998 case 37:
7999 {
8000 return 110;
8001 }
8002 default:
8003 {
8004 return -1;
8005 }
8006 }
8007 }
8008 case 98:
8009 {
8010 Lexeme prevMatch = token.match;
8011 token.match = lexeme;
8012 int tokenId = GetTokenId(8);
8013 if (tokenId == CONTINUE_TOKEN)
8014 {
8015 token.id = tokenId;
8016 return -1;
8017 }
8018 else if (tokenId != INVALID_TOKEN)
8019 {
8020 token.id = tokenId;
8021 }
8022 else
8023 {
8024 token.match = prevMatch;
8025 }
8026 switch (i)
8027 {
8028 case 2:
8029 case 3:
8030 case 5:
8031 case 6:
8032 case 7:
8033 case 9:
8034 case 10:
8035 case 11:
8036 case 12:
8037 case 13:
8038 case 25:
8039 case 26:
8040 case 27:
8041 case 34:
8042 case 35:
8043 case 36:
8044 case 38:
8045 case 39:
8046 case 40:
8047 case 41:
8048 case 42:
8049 case 43:
8050 case 44:
8051 case 45:
8052 case 46:
8053 case 47:
8054 case 48:
8055 case 49:
8056 case 50:
8057 case 51:
8058 case 52:
8059 case 53:
8060 case 54:
8061 case 55:
8062 {
8063 return 7;
8064 }
8065 case 0:
8066 {
8067 return 39;
8068 }
8069 case 1:
8070 {
8071 return 40;
8072 }
8073 case 4:
8074 {
8075 return 41;
8076 }
8077 case 8:
8078 {
8079 return 97;
8080 }
8081 case 14:
8082 case 15:
8083 case 16:
8084 case 17:
8085 case 18:
8086 case 19:
8087 case 20:
8088 case 21:
8089 case 22:
8090 case 23:
8091 case 24:
8092 case 28:
8093 case 29:
8094 case 30:
8095 case 31:
8096 {
8097 return 98;
8098 }
8099 case 32:
8100 case 33:
8101 {
8102 return 99;
8103 }
8104 case 37:
8105 {
8106 return 111;
8107 }
8108 default:
8109 {
8110 return -1;
8111 }
8112 }
8113 }
8114 case 111:
8115 {
8116 Lexeme prevMatch = token.match;
8117 token.match = lexeme;
8118 int tokenId = GetTokenId(8);
8119 if (tokenId == CONTINUE_TOKEN)
8120 {
8121 token.id = tokenId;
8122 return -1;
8123 }
8124 else if (tokenId != INVALID_TOKEN)
8125 {
8126 token.id = tokenId;
8127 }
8128 else
8129 {
8130 token.match = prevMatch;
8131 }
8132 switch (i)
8133 {
8134 case 2:
8135 case 3:
8136 case 5:
8137 case 6:
8138 case 7:
8139 case 9:
8140 case 10:
8141 case 11:
8142 case 12:
8143 case 13:
8144 case 25:
8145 case 26:
8146 case 27:
8147 case 34:
8148 case 35:
8149 case 36:
8150 case 38:
8151 case 39:
8152 case 40:
8153 case 41:
8154 case 42:
8155 case 43:
8156 case 44:
8157 case 45:
8158 case 46:
8159 case 47:
8160 case 48:
8161 case 49:
8162 case 50:
8163 case 51:
8164 case 52:
8165 case 53:
8166 case 54:
8167 case 55:
8168 {
8169 return 7;
8170 }
8171 case 0:
8172 {
8173 return 39;
8174 }
8175 case 1:
8176 {
8177 return 40;
8178 }
8179 case 4:
8180 {
8181 return 41;
8182 }
8183 case 8:
8184 {
8185 return 97;
8186 }
8187 case 14:
8188 case 15:
8189 case 16:
8190 case 17:
8191 case 18:
8192 case 19:
8193 case 20:
8194 case 21:
8195 case 22:
8196 case 23:
8197 case 24:
8198 case 28:
8199 case 29:
8200 case 30:
8201 case 31:
8202 {
8203 return 98;
8204 }
8205 case 32:
8206 case 33:
8207 {
8208 return 99;
8209 }
8210 case 37:
8211 {
8212 return 109;
8213 }
8214 default:
8215 {
8216 return -1;
8217 }
8218 }
8219 }
8220 case 97:
8221 {
8222 switch (i)
8223 {
8224 case 2:
8225 case 3:
8226 case 5:
8227 case 6:
8228 case 7:
8229 case 8:
8230 case 9:
8231 case 10:
8232 case 11:
8233 case 12:
8234 case 13:
8235 case 14:
8236 case 17:
8237 case 18:
8238 case 19:
8239 case 20:
8240 case 21:
8241 case 22:
8242 case 23:
8243 case 24:
8244 case 25:
8245 case 26:
8246 case 27:
8247 case 28:
8248 case 29:
8249 case 30:
8250 case 31:
8251 case 32:
8252 case 33:
8253 case 34:
8254 case 35:
8255 case 36:
8256 case 37:
8257 case 38:
8258 case 39:
8259 case 40:
8260 case 41:
8261 case 42:
8262 case 43:
8263 case 44:
8264 case 45:
8265 case 46:
8266 case 47:
8267 case 48:
8268 case 49:
8269 case 50:
8270 case 51:
8271 case 52:
8272 case 53:
8273 case 54:
8274 case 55:
8275 {
8276 return 7;
8277 }
8278 case 0:
8279 {
8280 return 39;
8281 }
8282 case 1:
8283 {
8284 return 40;
8285 }
8286 case 4:
8287 {
8288 return 41;
8289 }
8290 case 15:
8291 {
8292 return 112;
8293 }
8294 case 16:
8295 {
8296 return 113;
8297 }
8298 default:
8299 {
8300 return -1;
8301 }
8302 }
8303 }
8304 case 113:
8305 {
8306 switch (i)
8307 {
8308 case 2:
8309 case 3:
8310 case 5:
8311 case 6:
8312 case 7:
8313 case 8:
8314 case 9:
8315 case 10:
8316 case 11:
8317 case 12:
8318 case 13:
8319 case 14:
8320 case 15:
8321 case 16:
8322 case 17:
8323 case 18:
8324 case 19:
8325 case 20:
8326 case 21:
8327 case 22:
8328 case 23:
8329 case 24:
8330 case 34:
8331 case 35:
8332 case 36:
8333 case 37:
8334 case 38:
8335 case 39:
8336 case 40:
8337 case 41:
8338 case 42:
8339 case 43:
8340 case 44:
8341 case 45:
8342 case 46:
8343 case 47:
8344 case 48:
8345 case 49:
8346 case 50:
8347 case 51:
8348 case 52:
8349 case 53:
8350 case 54:
8351 case 55:
8352 {
8353 return 7;
8354 }
8355 case 0:
8356 {
8357 return 39;
8358 }
8359 case 1:
8360 {
8361 return 40;
8362 }
8363 case 4:
8364 {
8365 return 41;
8366 }
8367 case 25:
8368 case 26:
8369 case 27:
8370 case 28:
8371 case 29:
8372 case 30:
8373 case 31:
8374 case 32:
8375 case 33:
8376 {
8377 return 114;
8378 }
8379 default:
8380 {
8381 return -1;
8382 }
8383 }
8384 }
8385 case 114:
8386 {
8387 switch (i)
8388 {
8389 case 2:
8390 case 3:
8391 case 5:
8392 case 6:
8393 case 7:
8394 case 8:
8395 case 9:
8396 case 10:
8397 case 11:
8398 case 12:
8399 case 13:
8400 case 14:
8401 case 15:
8402 case 16:
8403 case 17:
8404 case 18:
8405 case 19:
8406 case 20:
8407 case 21:
8408 case 22:
8409 case 23:
8410 case 24:
8411 case 34:
8412 case 35:
8413 case 36:
8414 case 37:
8415 case 38:
8416 case 39:
8417 case 40:
8418 case 41:
8419 case 42:
8420 case 43:
8421 case 44:
8422 case 45:
8423 case 46:
8424 case 47:
8425 case 48:
8426 case 49:
8427 case 50:
8428 case 51:
8429 case 52:
8430 case 53:
8431 case 54:
8432 case 55:
8433 {
8434 return 7;
8435 }
8436 case 0:
8437 {
8438 return 39;
8439 }
8440 case 1:
8441 {
8442 return 40;
8443 }
8444 case 4:
8445 {
8446 return 41;
8447 }
8448 case 25:
8449 case 26:
8450 case 27:
8451 case 28:
8452 case 29:
8453 case 30:
8454 case 31:
8455 case 32:
8456 case 33:
8457 {
8458 return 115;
8459 }
8460 default:
8461 {
8462 return -1;
8463 }
8464 }
8465 }
8466 case 115:
8467 {
8468 switch (i)
8469 {
8470 case 2:
8471 case 3:
8472 case 5:
8473 case 6:
8474 case 7:
8475 case 8:
8476 case 9:
8477 case 10:
8478 case 11:
8479 case 12:
8480 case 13:
8481 case 14:
8482 case 15:
8483 case 16:
8484 case 17:
8485 case 18:
8486 case 19:
8487 case 20:
8488 case 21:
8489 case 22:
8490 case 23:
8491 case 24:
8492 case 34:
8493 case 35:
8494 case 36:
8495 case 37:
8496 case 38:
8497 case 39:
8498 case 40:
8499 case 41:
8500 case 42:
8501 case 43:
8502 case 44:
8503 case 45:
8504 case 46:
8505 case 47:
8506 case 48:
8507 case 49:
8508 case 50:
8509 case 51:
8510 case 52:
8511 case 53:
8512 case 54:
8513 case 55:
8514 {
8515 return 7;
8516 }
8517 case 0:
8518 {
8519 return 39;
8520 }
8521 case 1:
8522 {
8523 return 40;
8524 }
8525 case 4:
8526 {
8527 return 41;
8528 }
8529 case 25:
8530 case 26:
8531 case 27:
8532 case 28:
8533 case 29:
8534 case 30:
8535 case 31:
8536 case 32:
8537 case 33:
8538 {
8539 return 116;
8540 }
8541 default:
8542 {
8543 return -1;
8544 }
8545 }
8546 }
8547 case 116:
8548 {
8549 switch (i)
8550 {
8551 case 2:
8552 case 3:
8553 case 5:
8554 case 6:
8555 case 7:
8556 case 8:
8557 case 9:
8558 case 10:
8559 case 11:
8560 case 12:
8561 case 13:
8562 case 14:
8563 case 15:
8564 case 16:
8565 case 17:
8566 case 18:
8567 case 19:
8568 case 20:
8569 case 21:
8570 case 22:
8571 case 23:
8572 case 24:
8573 case 34:
8574 case 35:
8575 case 36:
8576 case 37:
8577 case 38:
8578 case 39:
8579 case 40:
8580 case 41:
8581 case 42:
8582 case 43:
8583 case 44:
8584 case 45:
8585 case 46:
8586 case 47:
8587 case 48:
8588 case 49:
8589 case 50:
8590 case 51:
8591 case 52:
8592 case 53:
8593 case 54:
8594 case 55:
8595 {
8596 return 7;
8597 }
8598 case 0:
8599 {
8600 return 39;
8601 }
8602 case 1:
8603 {
8604 return 40;
8605 }
8606 case 4:
8607 {
8608 return 41;
8609 }
8610 case 25:
8611 case 26:
8612 case 27:
8613 case 28:
8614 case 29:
8615 case 30:
8616 case 31:
8617 case 32:
8618 case 33:
8619 {
8620 return 117;
8621 }
8622 default:
8623 {
8624 return -1;
8625 }
8626 }
8627 }
8628 case 117:
8629 {
8630 switch (i)
8631 {
8632 case 2:
8633 case 3:
8634 case 5:
8635 case 6:
8636 case 7:
8637 case 8:
8638 case 9:
8639 case 10:
8640 case 11:
8641 case 12:
8642 case 13:
8643 case 14:
8644 case 15:
8645 case 16:
8646 case 17:
8647 case 18:
8648 case 19:
8649 case 20:
8650 case 21:
8651 case 22:
8652 case 23:
8653 case 24:
8654 case 34:
8655 case 35:
8656 case 36:
8657 case 37:
8658 case 38:
8659 case 39:
8660 case 40:
8661 case 41:
8662 case 42:
8663 case 43:
8664 case 44:
8665 case 45:
8666 case 46:
8667 case 47:
8668 case 48:
8669 case 49:
8670 case 50:
8671 case 51:
8672 case 52:
8673 case 53:
8674 case 54:
8675 case 55:
8676 {
8677 return 7;
8678 }
8679 case 0:
8680 {
8681 return 39;
8682 }
8683 case 1:
8684 {
8685 return 40;
8686 }
8687 case 4:
8688 {
8689 return 41;
8690 }
8691 case 25:
8692 case 26:
8693 case 27:
8694 case 28:
8695 case 29:
8696 case 30:
8697 case 31:
8698 case 32:
8699 case 33:
8700 {
8701 return 118;
8702 }
8703 default:
8704 {
8705 return -1;
8706 }
8707 }
8708 }
8709 case 118:
8710 {
8711 switch (i)
8712 {
8713 case 2:
8714 case 3:
8715 case 5:
8716 case 6:
8717 case 7:
8718 case 8:
8719 case 9:
8720 case 10:
8721 case 11:
8722 case 12:
8723 case 13:
8724 case 14:
8725 case 15:
8726 case 16:
8727 case 17:
8728 case 18:
8729 case 19:
8730 case 20:
8731 case 21:
8732 case 22:
8733 case 23:
8734 case 24:
8735 case 34:
8736 case 35:
8737 case 36:
8738 case 37:
8739 case 38:
8740 case 39:
8741 case 40:
8742 case 41:
8743 case 42:
8744 case 43:
8745 case 44:
8746 case 45:
8747 case 46:
8748 case 47:
8749 case 48:
8750 case 49:
8751 case 50:
8752 case 51:
8753 case 52:
8754 case 53:
8755 case 54:
8756 case 55:
8757 {
8758 return 7;
8759 }
8760 case 0:
8761 {
8762 return 39;
8763 }
8764 case 1:
8765 {
8766 return 40;
8767 }
8768 case 4:
8769 {
8770 return 41;
8771 }
8772 case 25:
8773 case 26:
8774 case 27:
8775 case 28:
8776 case 29:
8777 case 30:
8778 case 31:
8779 case 32:
8780 case 33:
8781 {
8782 return 119;
8783 }
8784 default:
8785 {
8786 return -1;
8787 }
8788 }
8789 }
8790 case 119:
8791 {
8792 switch (i)
8793 {
8794 case 2:
8795 case 3:
8796 case 5:
8797 case 6:
8798 case 7:
8799 case 8:
8800 case 9:
8801 case 10:
8802 case 11:
8803 case 12:
8804 case 13:
8805 case 14:
8806 case 15:
8807 case 16:
8808 case 17:
8809 case 18:
8810 case 19:
8811 case 20:
8812 case 21:
8813 case 22:
8814 case 23:
8815 case 24:
8816 case 34:
8817 case 35:
8818 case 36:
8819 case 37:
8820 case 38:
8821 case 39:
8822 case 40:
8823 case 41:
8824 case 42:
8825 case 43:
8826 case 44:
8827 case 45:
8828 case 46:
8829 case 47:
8830 case 48:
8831 case 49:
8832 case 50:
8833 case 51:
8834 case 52:
8835 case 53:
8836 case 54:
8837 case 55:
8838 {
8839 return 7;
8840 }
8841 case 0:
8842 {
8843 return 39;
8844 }
8845 case 1:
8846 {
8847 return 40;
8848 }
8849 case 4:
8850 {
8851 return 41;
8852 }
8853 case 25:
8854 case 26:
8855 case 27:
8856 case 28:
8857 case 29:
8858 case 30:
8859 case 31:
8860 case 32:
8861 case 33:
8862 {
8863 return 120;
8864 }
8865 default:
8866 {
8867 return -1;
8868 }
8869 }
8870 }
8871 case 120:
8872 {
8873 switch (i)
8874 {
8875 case 2:
8876 case 3:
8877 case 5:
8878 case 6:
8879 case 7:
8880 case 8:
8881 case 9:
8882 case 10:
8883 case 11:
8884 case 12:
8885 case 13:
8886 case 14:
8887 case 15:
8888 case 16:
8889 case 17:
8890 case 18:
8891 case 19:
8892 case 20:
8893 case 21:
8894 case 22:
8895 case 23:
8896 case 24:
8897 case 34:
8898 case 35:
8899 case 36:
8900 case 37:
8901 case 38:
8902 case 39:
8903 case 40:
8904 case 41:
8905 case 42:
8906 case 43:
8907 case 44:
8908 case 45:
8909 case 46:
8910 case 47:
8911 case 48:
8912 case 49:
8913 case 50:
8914 case 51:
8915 case 52:
8916 case 53:
8917 case 54:
8918 case 55:
8919 {
8920 return 7;
8921 }
8922 case 0:
8923 {
8924 return 39;
8925 }
8926 case 1:
8927 {
8928 return 40;
8929 }
8930 case 4:
8931 {
8932 return 41;
8933 }
8934 case 25:
8935 case 26:
8936 case 27:
8937 case 28:
8938 case 29:
8939 case 30:
8940 case 31:
8941 case 32:
8942 case 33:
8943 {
8944 return 121;
8945 }
8946 default:
8947 {
8948 return -1;
8949 }
8950 }
8951 }
8952 case 121:
8953 {
8954 Lexeme prevMatch = token.match;
8955 token.match = lexeme;
8956 int tokenId = GetTokenId(8);
8957 if (tokenId == CONTINUE_TOKEN)
8958 {
8959 token.id = tokenId;
8960 return -1;
8961 }
8962 else if (tokenId != INVALID_TOKEN)
8963 {
8964 token.id = tokenId;
8965 }
8966 else
8967 {
8968 token.match = prevMatch;
8969 }
8970 switch (i)
8971 {
8972 case 2:
8973 case 3:
8974 case 5:
8975 case 6:
8976 case 7:
8977 case 9:
8978 case 10:
8979 case 11:
8980 case 12:
8981 case 13:
8982 case 25:
8983 case 26:
8984 case 27:
8985 case 34:
8986 case 35:
8987 case 36:
8988 case 38:
8989 case 39:
8990 case 40:
8991 case 41:
8992 case 42:
8993 case 43:
8994 case 44:
8995 case 45:
8996 case 46:
8997 case 47:
8998 case 48:
8999 case 49:
9000 case 50:
9001 case 51:
9002 case 52:
9003 case 53:
9004 case 54:
9005 case 55:
9006 {
9007 return 7;
9008 }
9009 case 0:
9010 {
9011 return 39;
9012 }
9013 case 1:
9014 {
9015 return 40;
9016 }
9017 case 4:
9018 {
9019 return 41;
9020 }
9021 case 8:
9022 {
9023 return 97;
9024 }
9025 case 14:
9026 case 15:
9027 case 16:
9028 case 17:
9029 case 18:
9030 case 19:
9031 case 20:
9032 case 21:
9033 case 22:
9034 case 23:
9035 case 24:
9036 case 28:
9037 case 29:
9038 case 30:
9039 case 31:
9040 {
9041 return 98;
9042 }
9043 case 32:
9044 case 33:
9045 {
9046 return 99;
9047 }
9048 case 37:
9049 {
9050 return 122;
9051 }
9052 default:
9053 {
9054 return -1;
9055 }
9056 }
9057 }
9058 case 122:
9059 {
9060 Lexeme prevMatch = token.match;
9061 token.match = lexeme;
9062 int tokenId = GetTokenId(8);
9063 if (tokenId == CONTINUE_TOKEN)
9064 {
9065 token.id = tokenId;
9066 return -1;
9067 }
9068 else if (tokenId != INVALID_TOKEN)
9069 {
9070 token.id = tokenId;
9071 }
9072 else
9073 {
9074 token.match = prevMatch;
9075 }
9076 switch (i)
9077 {
9078 case 2:
9079 case 3:
9080 case 5:
9081 case 6:
9082 case 7:
9083 case 9:
9084 case 10:
9085 case 11:
9086 case 12:
9087 case 13:
9088 case 25:
9089 case 26:
9090 case 27:
9091 case 34:
9092 case 35:
9093 case 36:
9094 case 38:
9095 case 39:
9096 case 40:
9097 case 41:
9098 case 42:
9099 case 43:
9100 case 44:
9101 case 45:
9102 case 46:
9103 case 47:
9104 case 48:
9105 case 49:
9106 case 50:
9107 case 51:
9108 case 52:
9109 case 53:
9110 case 54:
9111 case 55:
9112 {
9113 return 7;
9114 }
9115 case 0:
9116 {
9117 return 39;
9118 }
9119 case 1:
9120 {
9121 return 40;
9122 }
9123 case 4:
9124 {
9125 return 41;
9126 }
9127 case 8:
9128 {
9129 return 97;
9130 }
9131 case 14:
9132 case 15:
9133 case 16:
9134 case 17:
9135 case 18:
9136 case 19:
9137 case 20:
9138 case 21:
9139 case 22:
9140 case 23:
9141 case 24:
9142 case 28:
9143 case 29:
9144 case 30:
9145 case 31:
9146 {
9147 return 98;
9148 }
9149 case 32:
9150 case 33:
9151 {
9152 return 99;
9153 }
9154 case 37:
9155 {
9156 return 111;
9157 }
9158 default:
9159 {
9160 return -1;
9161 }
9162 }
9163 }
9164 case 112:
9165 {
9166 switch (i)
9167 {
9168 case 2:
9169 case 3:
9170 case 5:
9171 case 6:
9172 case 7:
9173 case 8:
9174 case 9:
9175 case 10:
9176 case 11:
9177 case 12:
9178 case 13:
9179 case 14:
9180 case 15:
9181 case 16:
9182 case 17:
9183 case 18:
9184 case 19:
9185 case 20:
9186 case 21:
9187 case 22:
9188 case 23:
9189 case 24:
9190 case 34:
9191 case 35:
9192 case 36:
9193 case 37:
9194 case 38:
9195 case 39:
9196 case 40:
9197 case 41:
9198 case 42:
9199 case 43:
9200 case 44:
9201 case 45:
9202 case 46:
9203 case 47:
9204 case 48:
9205 case 49:
9206 case 50:
9207 case 51:
9208 case 52:
9209 case 53:
9210 case 54:
9211 case 55:
9212 {
9213 return 7;
9214 }
9215 case 0:
9216 {
9217 return 39;
9218 }
9219 case 1:
9220 {
9221 return 40;
9222 }
9223 case 4:
9224 {
9225 return 41;
9226 }
9227 case 25:
9228 case 26:
9229 case 27:
9230 case 28:
9231 case 29:
9232 case 30:
9233 case 31:
9234 case 32:
9235 case 33:
9236 {
9237 return 123;
9238 }
9239 default:
9240 {
9241 return -1;
9242 }
9243 }
9244 }
9245 case 123:
9246 {
9247 switch (i)
9248 {
9249 case 2:
9250 case 3:
9251 case 5:
9252 case 6:
9253 case 7:
9254 case 8:
9255 case 9:
9256 case 10:
9257 case 11:
9258 case 12:
9259 case 13:
9260 case 14:
9261 case 15:
9262 case 16:
9263 case 17:
9264 case 18:
9265 case 19:
9266 case 20:
9267 case 21:
9268 case 22:
9269 case 23:
9270 case 24:
9271 case 34:
9272 case 35:
9273 case 36:
9274 case 37:
9275 case 38:
9276 case 39:
9277 case 40:
9278 case 41:
9279 case 42:
9280 case 43:
9281 case 44:
9282 case 45:
9283 case 46:
9284 case 47:
9285 case 48:
9286 case 49:
9287 case 50:
9288 case 51:
9289 case 52:
9290 case 53:
9291 case 54:
9292 case 55:
9293 {
9294 return 7;
9295 }
9296 case 0:
9297 {
9298 return 39;
9299 }
9300 case 1:
9301 {
9302 return 40;
9303 }
9304 case 4:
9305 {
9306 return 41;
9307 }
9308 case 25:
9309 case 26:
9310 case 27:
9311 case 28:
9312 case 29:
9313 case 30:
9314 case 31:
9315 case 32:
9316 case 33:
9317 {
9318 return 124;
9319 }
9320 default:
9321 {
9322 return -1;
9323 }
9324 }
9325 }
9326 case 124:
9327 {
9328 switch (i)
9329 {
9330 case 2:
9331 case 3:
9332 case 5:
9333 case 6:
9334 case 7:
9335 case 8:
9336 case 9:
9337 case 10:
9338 case 11:
9339 case 12:
9340 case 13:
9341 case 14:
9342 case 15:
9343 case 16:
9344 case 17:
9345 case 18:
9346 case 19:
9347 case 20:
9348 case 21:
9349 case 22:
9350 case 23:
9351 case 24:
9352 case 34:
9353 case 35:
9354 case 36:
9355 case 37:
9356 case 38:
9357 case 39:
9358 case 40:
9359 case 41:
9360 case 42:
9361 case 43:
9362 case 44:
9363 case 45:
9364 case 46:
9365 case 47:
9366 case 48:
9367 case 49:
9368 case 50:
9369 case 51:
9370 case 52:
9371 case 53:
9372 case 54:
9373 case 55:
9374 {
9375 return 7;
9376 }
9377 case 0:
9378 {
9379 return 39;
9380 }
9381 case 1:
9382 {
9383 return 40;
9384 }
9385 case 4:
9386 {
9387 return 41;
9388 }
9389 case 25:
9390 case 26:
9391 case 27:
9392 case 28:
9393 case 29:
9394 case 30:
9395 case 31:
9396 case 32:
9397 case 33:
9398 {
9399 return 125;
9400 }
9401 default:
9402 {
9403 return -1;
9404 }
9405 }
9406 }
9407 case 125:
9408 {
9409 switch (i)
9410 {
9411 case 2:
9412 case 3:
9413 case 5:
9414 case 6:
9415 case 7:
9416 case 8:
9417 case 9:
9418 case 10:
9419 case 11:
9420 case 12:
9421 case 13:
9422 case 14:
9423 case 15:
9424 case 16:
9425 case 17:
9426 case 18:
9427 case 19:
9428 case 20:
9429 case 21:
9430 case 22:
9431 case 23:
9432 case 24:
9433 case 34:
9434 case 35:
9435 case 36:
9436 case 37:
9437 case 38:
9438 case 39:
9439 case 40:
9440 case 41:
9441 case 42:
9442 case 43:
9443 case 44:
9444 case 45:
9445 case 46:
9446 case 47:
9447 case 48:
9448 case 49:
9449 case 50:
9450 case 51:
9451 case 52:
9452 case 53:
9453 case 54:
9454 case 55:
9455 {
9456 return 7;
9457 }
9458 case 0:
9459 {
9460 return 39;
9461 }
9462 case 1:
9463 {
9464 return 40;
9465 }
9466 case 4:
9467 {
9468 return 41;
9469 }
9470 case 25:
9471 case 26:
9472 case 27:
9473 case 28:
9474 case 29:
9475 case 30:
9476 case 31:
9477 case 32:
9478 case 33:
9479 {
9480 return 126;
9481 }
9482 default:
9483 {
9484 return -1;
9485 }
9486 }
9487 }
9488 case 126:
9489 {
9490 Lexeme prevMatch = token.match;
9491 token.match = lexeme;
9492 int tokenId = GetTokenId(8);
9493 if (tokenId == CONTINUE_TOKEN)
9494 {
9495 token.id = tokenId;
9496 return -1;
9497 }
9498 else if (tokenId != INVALID_TOKEN)
9499 {
9500 token.id = tokenId;
9501 }
9502 else
9503 {
9504 token.match = prevMatch;
9505 }
9506 switch (i)
9507 {
9508 case 2:
9509 case 3:
9510 case 5:
9511 case 6:
9512 case 7:
9513 case 9:
9514 case 10:
9515 case 11:
9516 case 12:
9517 case 13:
9518 case 25:
9519 case 26:
9520 case 27:
9521 case 34:
9522 case 35:
9523 case 36:
9524 case 38:
9525 case 39:
9526 case 40:
9527 case 41:
9528 case 42:
9529 case 43:
9530 case 44:
9531 case 45:
9532 case 46:
9533 case 47:
9534 case 48:
9535 case 49:
9536 case 50:
9537 case 51:
9538 case 52:
9539 case 53:
9540 case 54:
9541 case 55:
9542 {
9543 return 7;
9544 }
9545 case 0:
9546 {
9547 return 39;
9548 }
9549 case 1:
9550 {
9551 return 40;
9552 }
9553 case 4:
9554 {
9555 return 41;
9556 }
9557 case 8:
9558 {
9559 return 97;
9560 }
9561 case 14:
9562 case 15:
9563 case 16:
9564 case 17:
9565 case 18:
9566 case 19:
9567 case 20:
9568 case 21:
9569 case 22:
9570 case 23:
9571 case 24:
9572 case 28:
9573 case 29:
9574 case 30:
9575 case 31:
9576 {
9577 return 98;
9578 }
9579 case 32:
9580 case 33:
9581 {
9582 return 99;
9583 }
9584 case 37:
9585 {
9586 return 122;
9587 }
9588 default:
9589 {
9590 return -1;
9591 }
9592 }
9593 }
9594 case 19:
9595 {
9596 Lexeme prevMatch = token.match;
9597 token.match = lexeme;
9598 int tokenId = GetTokenId(9);
9599 if (tokenId == CONTINUE_TOKEN)
9600 {
9601 token.id = tokenId;
9602 return -1;
9603 }
9604 else if (tokenId != INVALID_TOKEN)
9605 {
9606 token.id = tokenId;
9607 }
9608 else
9609 {
9610 token.match = prevMatch;
9611 }
9612 switch (i)
9613 {
9614 case 0:
9615 {
9616 return 39;
9617 }
9618 case 1:
9619 {
9620 return 40;
9621 }
9622 case 2:
9623 case 3:
9624 case 5:
9625 case 6:
9626 case 7:
9627 case 8:
9628 case 9:
9629 case 10:
9630 case 11:
9631 case 12:
9632 case 13:
9633 case 14:
9634 case 15:
9635 case 16:
9636 case 17:
9637 case 18:
9638 case 19:
9639 case 20:
9640 case 21:
9641 case 22:
9642 case 23:
9643 case 24:
9644 case 25:
9645 case 26:
9646 case 27:
9647 case 28:
9648 case 29:
9649 case 30:
9650 case 31:
9651 case 32:
9652 case 33:
9653 case 34:
9654 case 35:
9655 case 36:
9656 case 38:
9657 case 39:
9658 case 40:
9659 case 41:
9660 case 42:
9661 case 43:
9662 case 44:
9663 case 45:
9664 case 46:
9665 case 47:
9666 case 48:
9667 case 49:
9668 case 50:
9669 case 51:
9670 case 52:
9671 case 53:
9672 case 54:
9673 case 55:
9674 {
9675 return 127;
9676 }
9677 case 4:
9678 {
9679 return 128;
9680 }
9681 case 37:
9682 {
9683 return 129;
9684 }
9685 default:
9686 {
9687 return -1;
9688 }
9689 }
9690 }
9691 case 129:
9692 {
9693 Lexeme prevMatch = token.match;
9694 token.match = lexeme;
9695 int tokenId = GetTokenId(9);
9696 if (tokenId == CONTINUE_TOKEN)
9697 {
9698 token.id = tokenId;
9699 return -1;
9700 }
9701 else if (tokenId != INVALID_TOKEN)
9702 {
9703 token.id = tokenId;
9704 }
9705 else
9706 {
9707 token.match = prevMatch;
9708 }
9709 switch (i)
9710 {
9711 case 37:
9712 {
9713 return 7;
9714 }
9715 case 0:
9716 {
9717 return 39;
9718 }
9719 case 1:
9720 {
9721 return 40;
9722 }
9723 case 2:
9724 case 3:
9725 case 5:
9726 case 6:
9727 case 7:
9728 case 8:
9729 case 9:
9730 case 10:
9731 case 11:
9732 case 12:
9733 case 13:
9734 case 14:
9735 case 15:
9736 case 16:
9737 case 17:
9738 case 18:
9739 case 19:
9740 case 20:
9741 case 21:
9742 case 22:
9743 case 23:
9744 case 24:
9745 case 25:
9746 case 26:
9747 case 27:
9748 case 28:
9749 case 29:
9750 case 30:
9751 case 31:
9752 case 32:
9753 case 33:
9754 case 34:
9755 case 35:
9756 case 36:
9757 case 38:
9758 case 39:
9759 case 40:
9760 case 41:
9761 case 42:
9762 case 43:
9763 case 44:
9764 case 45:
9765 case 46:
9766 case 47:
9767 case 48:
9768 case 49:
9769 case 50:
9770 case 51:
9771 case 52:
9772 case 53:
9773 case 54:
9774 case 55:
9775 {
9776 return 127;
9777 }
9778 case 4:
9779 {
9780 return 128;
9781 }
9782 default:
9783 {
9784 return -1;
9785 }
9786 }
9787 }
9788 case 128:
9789 {
9790 Lexeme prevMatch = token.match;
9791 token.match = lexeme;
9792 int tokenId = GetTokenId(9);
9793 if (tokenId == CONTINUE_TOKEN)
9794 {
9795 token.id = tokenId;
9796 return -1;
9797 }
9798 else if (tokenId != INVALID_TOKEN)
9799 {
9800 token.id = tokenId;
9801 }
9802 else
9803 {
9804 token.match = prevMatch;
9805 }
9806 switch (i)
9807 {
9808 case 0:
9809 {
9810 return 39;
9811 }
9812 case 1:
9813 {
9814 return 40;
9815 }
9816 case 4:
9817 {
9818 return 128;
9819 }
9820 case 2:
9821 case 5:
9822 case 6:
9823 case 7:
9824 case 8:
9825 case 9:
9826 case 10:
9827 case 11:
9828 case 12:
9829 case 13:
9830 case 14:
9831 case 15:
9832 case 16:
9833 case 17:
9834 case 18:
9835 case 19:
9836 case 20:
9837 case 21:
9838 case 22:
9839 case 23:
9840 case 24:
9841 case 25:
9842 case 26:
9843 case 27:
9844 case 28:
9845 case 29:
9846 case 30:
9847 case 31:
9848 case 32:
9849 case 33:
9850 case 34:
9851 case 35:
9852 case 36:
9853 case 38:
9854 case 39:
9855 case 40:
9856 case 41:
9857 case 42:
9858 case 43:
9859 case 44:
9860 case 45:
9861 case 46:
9862 case 47:
9863 case 48:
9864 case 49:
9865 case 50:
9866 case 51:
9867 case 52:
9868 case 53:
9869 case 54:
9870 case 55:
9871 {
9872 return 130;
9873 }
9874 case 3:
9875 {
9876 return 131;
9877 }
9878 case 37:
9879 {
9880 return 132;
9881 }
9882 default:
9883 {
9884 return -1;
9885 }
9886 }
9887 }
9888 case 132:
9889 {
9890 Lexeme prevMatch = token.match;
9891 token.match = lexeme;
9892 int tokenId = GetTokenId(9);
9893 if (tokenId == CONTINUE_TOKEN)
9894 {
9895 token.id = tokenId;
9896 return -1;
9897 }
9898 else if (tokenId != INVALID_TOKEN)
9899 {
9900 token.id = tokenId;
9901 }
9902 else
9903 {
9904 token.match = prevMatch;
9905 }
9906 switch (i)
9907 {
9908 case 37:
9909 {
9910 return 7;
9911 }
9912 case 0:
9913 {
9914 return 39;
9915 }
9916 case 1:
9917 {
9918 return 40;
9919 }
9920 case 2:
9921 case 3:
9922 case 5:
9923 case 6:
9924 case 7:
9925 case 8:
9926 case 9:
9927 case 10:
9928 case 11:
9929 case 12:
9930 case 13:
9931 case 14:
9932 case 15:
9933 case 16:
9934 case 17:
9935 case 18:
9936 case 19:
9937 case 20:
9938 case 21:
9939 case 22:
9940 case 23:
9941 case 24:
9942 case 25:
9943 case 26:
9944 case 27:
9945 case 28:
9946 case 29:
9947 case 30:
9948 case 31:
9949 case 32:
9950 case 33:
9951 case 34:
9952 case 35:
9953 case 36:
9954 case 38:
9955 case 39:
9956 case 40:
9957 case 41:
9958 case 42:
9959 case 43:
9960 case 44:
9961 case 45:
9962 case 46:
9963 case 47:
9964 case 48:
9965 case 49:
9966 case 50:
9967 case 51:
9968 case 52:
9969 case 53:
9970 case 54:
9971 case 55:
9972 {
9973 return 127;
9974 }
9975 case 4:
9976 {
9977 return 128;
9978 }
9979 default:
9980 {
9981 return -1;
9982 }
9983 }
9984 }
9985 case 131:
9986 {
9987 Lexeme prevMatch = token.match;
9988 token.match = lexeme;
9989 int tokenId = GetTokenId(4);
9990 if (tokenId == CONTINUE_TOKEN)
9991 {
9992 token.id = tokenId;
9993 return -1;
9994 }
9995 else if (tokenId != INVALID_TOKEN)
9996 {
9997 token.id = tokenId;
9998 }
9999 else
10000 {
10001 token.match = prevMatch;
10002 }
10003 switch (i)
10004 {
10005 case 0:
10006 {
10007 return 39;
10008 }
10009 case 1:
10010 {
10011 return 40;
10012 }
10013 case 2:
10014 case 3:
10015 case 5:
10016 case 6:
10017 case 7:
10018 case 8:
10019 case 9:
10020 case 10:
10021 case 11:
10022 case 12:
10023 case 13:
10024 case 14:
10025 case 15:
10026 case 16:
10027 case 17:
10028 case 18:
10029 case 19:
10030 case 20:
10031 case 21:
10032 case 22:
10033 case 23:
10034 case 24:
10035 case 25:
10036 case 26:
10037 case 27:
10038 case 28:
10039 case 29:
10040 case 30:
10041 case 31:
10042 case 32:
10043 case 33:
10044 case 34:
10045 case 35:
10046 case 36:
10047 case 38:
10048 case 39:
10049 case 40:
10050 case 41:
10051 case 42:
10052 case 43:
10053 case 44:
10054 case 45:
10055 case 46:
10056 case 47:
10057 case 48:
10058 case 49:
10059 case 50:
10060 case 51:
10061 case 52:
10062 case 53:
10063 case 54:
10064 case 55:
10065 {
10066 return 127;
10067 }
10068 case 4:
10069 {
10070 return 128;
10071 }
10072 case 37:
10073 {
10074 return 133;
10075 }
10076 default:
10077 {
10078 return -1;
10079 }
10080 }
10081 }
10082 case 133:
10083 {
10084 Lexeme prevMatch = token.match;
10085 token.match = lexeme;
10086 int tokenId = GetTokenId(4);
10087 if (tokenId == CONTINUE_TOKEN)
10088 {
10089 token.id = tokenId;
10090 return -1;
10091 }
10092 else if (tokenId != INVALID_TOKEN)
10093 {
10094 token.id = tokenId;
10095 }
10096 else
10097 {
10098 token.match = prevMatch;
10099 }
10100 switch (i)
10101 {
10102 case 37:
10103 {
10104 return 7;
10105 }
10106 case 0:
10107 {
10108 return 39;
10109 }
10110 case 1:
10111 {
10112 return 40;
10113 }
10114 case 2:
10115 case 3:
10116 case 5:
10117 case 6:
10118 case 7:
10119 case 8:
10120 case 9:
10121 case 10:
10122 case 11:
10123 case 12:
10124 case 13:
10125 case 14:
10126 case 15:
10127 case 16:
10128 case 17:
10129 case 18:
10130 case 19:
10131 case 20:
10132 case 21:
10133 case 22:
10134 case 23:
10135 case 24:
10136 case 25:
10137 case 26:
10138 case 27:
10139 case 28:
10140 case 29:
10141 case 30:
10142 case 31:
10143 case 32:
10144 case 33:
10145 case 34:
10146 case 35:
10147 case 36:
10148 case 38:
10149 case 39:
10150 case 40:
10151 case 41:
10152 case 42:
10153 case 43:
10154 case 44:
10155 case 45:
10156 case 46:
10157 case 47:
10158 case 48:
10159 case 49:
10160 case 50:
10161 case 51:
10162 case 52:
10163 case 53:
10164 case 54:
10165 case 55:
10166 {
10167 return 127;
10168 }
10169 case 4:
10170 {
10171 return 128;
10172 }
10173 default:
10174 {
10175 return -1;
10176 }
10177 }
10178 }
10179 case 130:
10180 {
10181 Lexeme prevMatch = token.match;
10182 token.match = lexeme;
10183 int tokenId = GetTokenId(9);
10184 if (tokenId == CONTINUE_TOKEN)
10185 {
10186 token.id = tokenId;
10187 return -1;
10188 }
10189 else if (tokenId != INVALID_TOKEN)
10190 {
10191 token.id = tokenId;
10192 }
10193 else
10194 {
10195 token.match = prevMatch;
10196 }
10197 switch (i)
10198 {
10199 case 0:
10200 {
10201 return 39;
10202 }
10203 case 1:
10204 {
10205 return 40;
10206 }
10207 case 2:
10208 case 3:
10209 case 5:
10210 case 6:
10211 case 7:
10212 case 8:
10213 case 9:
10214 case 10:
10215 case 11:
10216 case 12:
10217 case 13:
10218 case 14:
10219 case 15:
10220 case 16:
10221 case 17:
10222 case 18:
10223 case 19:
10224 case 20:
10225 case 21:
10226 case 22:
10227 case 23:
10228 case 24:
10229 case 25:
10230 case 26:
10231 case 27:
10232 case 28:
10233 case 29:
10234 case 30:
10235 case 31:
10236 case 32:
10237 case 33:
10238 case 34:
10239 case 35:
10240 case 36:
10241 case 38:
10242 case 39:
10243 case 40:
10244 case 41:
10245 case 42:
10246 case 43:
10247 case 44:
10248 case 45:
10249 case 46:
10250 case 47:
10251 case 48:
10252 case 49:
10253 case 50:
10254 case 51:
10255 case 52:
10256 case 53:
10257 case 54:
10258 case 55:
10259 {
10260 return 127;
10261 }
10262 case 4:
10263 {
10264 return 128;
10265 }
10266 case 37:
10267 {
10268 return 129;
10269 }
10270 default:
10271 {
10272 return -1;
10273 }
10274 }
10275 }
10276 case 127:
10277 {
10278 Lexeme prevMatch = token.match;
10279 token.match = lexeme;
10280 int tokenId = GetTokenId(9);
10281 if (tokenId == CONTINUE_TOKEN)
10282 {
10283 token.id = tokenId;
10284 return -1;
10285 }
10286 else if (tokenId != INVALID_TOKEN)
10287 {
10288 token.id = tokenId;
10289 }
10290 else
10291 {
10292 token.match = prevMatch;
10293 }
10294 switch (i)
10295 {
10296 case 0:
10297 {
10298 return 39;
10299 }
10300 case 1:
10301 {
10302 return 40;
10303 }
10304 case 2:
10305 case 3:
10306 case 5:
10307 case 6:
10308 case 7:
10309 case 8:
10310 case 9:
10311 case 10:
10312 case 11:
10313 case 12:
10314 case 13:
10315 case 14:
10316 case 15:
10317 case 16:
10318 case 17:
10319 case 18:
10320 case 19:
10321 case 20:
10322 case 21:
10323 case 22:
10324 case 23:
10325 case 24:
10326 case 25:
10327 case 26:
10328 case 27:
10329 case 28:
10330 case 29:
10331 case 30:
10332 case 31:
10333 case 32:
10334 case 33:
10335 case 34:
10336 case 35:
10337 case 36:
10338 case 38:
10339 case 39:
10340 case 40:
10341 case 41:
10342 case 42:
10343 case 43:
10344 case 44:
10345 case 45:
10346 case 46:
10347 case 47:
10348 case 48:
10349 case 49:
10350 case 50:
10351 case 51:
10352 case 52:
10353 case 53:
10354 case 54:
10355 case 55:
10356 {
10357 return 127;
10358 }
10359 case 4:
10360 {
10361 return 128;
10362 }
10363 case 37:
10364 {
10365 return 129;
10366 }
10367 default:
10368 {
10369 return -1;
10370 }
10371 }
10372 }
10373 case 18:
10374 {
10375 Lexeme prevMatch = token.match;
10376 token.match = lexeme;
10377 int tokenId = GetTokenId(0);
10378 if (tokenId == CONTINUE_TOKEN)
10379 {
10380 token.id = tokenId;
10381 return -1;
10382 }
10383 else if (tokenId != INVALID_TOKEN)
10384 {
10385 token.id = tokenId;
10386 }
10387 else
10388 {
10389 token.match = prevMatch;
10390 }
10391 switch (i)
10392 {
10393 case 2:
10394 case 3:
10395 case 5:
10396 case 6:
10397 case 7:
10398 case 8:
10399 case 9:
10400 case 10:
10401 case 11:
10402 case 12:
10403 case 13:
10404 case 14:
10405 case 15:
10406 case 16:
10407 case 17:
10408 case 18:
10409 case 19:
10410 case 20:
10411 case 21:
10412 case 22:
10413 case 23:
10414 case 24:
10415 case 25:
10416 case 26:
10417 case 27:
10418 case 28:
10419 case 29:
10420 case 30:
10421 case 31:
10422 case 32:
10423 case 33:
10424 case 38:
10425 case 39:
10426 case 40:
10427 case 41:
10428 case 42:
10429 case 43:
10430 case 44:
10431 case 45:
10432 case 46:
10433 case 47:
10434 case 48:
10435 case 49:
10436 case 50:
10437 case 51:
10438 case 52:
10439 case 53:
10440 case 54:
10441 case 55:
10442 {
10443 return 7;
10444 }
10445 case 34:
10446 case 35:
10447 {
10448 return 18;
10449 }
10450 case 36:
10451 {
10452 return 19;
10453 }
10454 case 0:
10455 {
10456 return 39;
10457 }
10458 case 1:
10459 {
10460 return 40;
10461 }
10462 case 4:
10463 {
10464 return 41;
10465 }
10466 case 37:
10467 {
10468 return 134;
10469 }
10470 default:
10471 {
10472 return -1;
10473 }
10474 }
10475 }
10476 case 134:
10477 {
10478 Lexeme prevMatch = token.match;
10479 token.match = lexeme;
10480 int tokenId = GetTokenId(0);
10481 if (tokenId == CONTINUE_TOKEN)
10482 {
10483 token.id = tokenId;
10484 return -1;
10485 }
10486 else if (tokenId != INVALID_TOKEN)
10487 {
10488 token.id = tokenId;
10489 }
10490 else
10491 {
10492 token.match = prevMatch;
10493 }
10494 switch (i)
10495 {
10496 case 2:
10497 case 3:
10498 case 5:
10499 case 6:
10500 case 7:
10501 case 8:
10502 case 9:
10503 case 10:
10504 case 11:
10505 case 12:
10506 case 13:
10507 case 14:
10508 case 15:
10509 case 16:
10510 case 17:
10511 case 18:
10512 case 19:
10513 case 20:
10514 case 21:
10515 case 22:
10516 case 23:
10517 case 24:
10518 case 25:
10519 case 26:
10520 case 27:
10521 case 28:
10522 case 29:
10523 case 30:
10524 case 31:
10525 case 32:
10526 case 33:
10527 case 38:
10528 case 39:
10529 case 40:
10530 case 41:
10531 case 42:
10532 case 43:
10533 case 44:
10534 case 45:
10535 case 46:
10536 case 47:
10537 case 48:
10538 case 49:
10539 case 50:
10540 case 51:
10541 case 52:
10542 case 53:
10543 case 54:
10544 case 55:
10545 {
10546 return 7;
10547 }
10548 case 34:
10549 case 35:
10550 {
10551 return 18;
10552 }
10553 case 36:
10554 {
10555 return 19;
10556 }
10557 case 0:
10558 {
10559 return 39;
10560 }
10561 case 1:
10562 {
10563 return 40;
10564 }
10565 case 4:
10566 {
10567 return 41;
10568 }
10569 case 37:
10570 {
10571 return 77;
10572 }
10573 default:
10574 {
10575 return -1;
10576 }
10577 }
10578 }
10579 case 17:
10580 {
10581 Lexeme prevMatch = token.match;
10582 token.match = lexeme;
10583 int tokenId = GetTokenId(8);
10584 if (tokenId == CONTINUE_TOKEN)
10585 {
10586 token.id = tokenId;
10587 return -1;
10588 }
10589 else if (tokenId != INVALID_TOKEN)
10590 {
10591 token.id = tokenId;
10592 }
10593 else
10594 {
10595 token.match = prevMatch;
10596 }
10597 switch (i)
10598 {
10599 case 2:
10600 case 3:
10601 case 5:
10602 case 6:
10603 case 7:
10604 case 9:
10605 case 10:
10606 case 12:
10607 case 13:
10608 case 34:
10609 case 35:
10610 case 36:
10611 case 38:
10612 case 39:
10613 case 40:
10614 case 41:
10615 case 42:
10616 case 43:
10617 case 44:
10618 case 45:
10619 case 46:
10620 case 47:
10621 case 48:
10622 case 49:
10623 case 50:
10624 case 51:
10625 case 52:
10626 case 53:
10627 case 54:
10628 case 55:
10629 {
10630 return 7;
10631 }
10632 case 25:
10633 case 26:
10634 case 27:
10635 {
10636 return 17;
10637 }
10638 case 0:
10639 {
10640 return 39;
10641 }
10642 case 1:
10643 {
10644 return 40;
10645 }
10646 case 4:
10647 {
10648 return 41;
10649 }
10650 case 8:
10651 {
10652 return 97;
10653 }
10654 case 14:
10655 case 15:
10656 case 16:
10657 case 17:
10658 case 18:
10659 case 19:
10660 case 20:
10661 case 21:
10662 case 22:
10663 case 23:
10664 case 24:
10665 case 28:
10666 case 29:
10667 case 30:
10668 case 31:
10669 {
10670 return 98;
10671 }
10672 case 32:
10673 case 33:
10674 {
10675 return 99;
10676 }
10677 case 11:
10678 {
10679 return 135;
10680 }
10681 case 37:
10682 {
10683 return 136;
10684 }
10685 default:
10686 {
10687 return -1;
10688 }
10689 }
10690 }
10691 case 136:
10692 {
10693 Lexeme prevMatch = token.match;
10694 token.match = lexeme;
10695 int tokenId = GetTokenId(8);
10696 if (tokenId == CONTINUE_TOKEN)
10697 {
10698 token.id = tokenId;
10699 return -1;
10700 }
10701 else if (tokenId != INVALID_TOKEN)
10702 {
10703 token.id = tokenId;
10704 }
10705 else
10706 {
10707 token.match = prevMatch;
10708 }
10709 switch (i)
10710 {
10711 case 2:
10712 case 3:
10713 case 5:
10714 case 6:
10715 case 7:
10716 case 9:
10717 case 10:
10718 case 12:
10719 case 13:
10720 case 34:
10721 case 35:
10722 case 36:
10723 case 38:
10724 case 39:
10725 case 40:
10726 case 41:
10727 case 42:
10728 case 43:
10729 case 44:
10730 case 45:
10731 case 46:
10732 case 47:
10733 case 48:
10734 case 49:
10735 case 50:
10736 case 51:
10737 case 52:
10738 case 53:
10739 case 54:
10740 case 55:
10741 {
10742 return 7;
10743 }
10744 case 25:
10745 case 26:
10746 case 27:
10747 {
10748 return 17;
10749 }
10750 case 0:
10751 {
10752 return 39;
10753 }
10754 case 1:
10755 {
10756 return 40;
10757 }
10758 case 4:
10759 {
10760 return 41;
10761 }
10762 case 8:
10763 {
10764 return 97;
10765 }
10766 case 14:
10767 case 15:
10768 case 16:
10769 case 17:
10770 case 18:
10771 case 19:
10772 case 20:
10773 case 21:
10774 case 22:
10775 case 23:
10776 case 24:
10777 case 28:
10778 case 29:
10779 case 30:
10780 case 31:
10781 {
10782 return 98;
10783 }
10784 case 32:
10785 case 33:
10786 {
10787 return 99;
10788 }
10789 case 11:
10790 case 37:
10791 {
10792 return 135;
10793 }
10794 default:
10795 {
10796 return -1;
10797 }
10798 }
10799 }
10800 case 135:
10801 {
10802 Lexeme prevMatch = token.match;
10803 token.match = lexeme;
10804 int tokenId = GetTokenId(8);
10805 if (tokenId == CONTINUE_TOKEN)
10806 {
10807 token.id = tokenId;
10808 return -1;
10809 }
10810 else if (tokenId != INVALID_TOKEN)
10811 {
10812 token.id = tokenId;
10813 }
10814 else
10815 {
10816 token.match = prevMatch;
10817 }
10818 switch (i)
10819 {
10820 case 2:
10821 case 3:
10822 case 5:
10823 case 6:
10824 case 7:
10825 case 9:
10826 case 10:
10827 case 11:
10828 case 12:
10829 case 13:
10830 case 25:
10831 case 26:
10832 case 27:
10833 case 34:
10834 case 35:
10835 case 36:
10836 case 38:
10837 case 39:
10838 case 40:
10839 case 41:
10840 case 42:
10841 case 43:
10842 case 44:
10843 case 45:
10844 case 46:
10845 case 47:
10846 case 48:
10847 case 49:
10848 case 50:
10849 case 51:
10850 case 52:
10851 case 53:
10852 case 54:
10853 case 55:
10854 {
10855 return 7;
10856 }
10857 case 0:
10858 {
10859 return 39;
10860 }
10861 case 1:
10862 {
10863 return 40;
10864 }
10865 case 4:
10866 {
10867 return 41;
10868 }
10869 case 8:
10870 {
10871 return 97;
10872 }
10873 case 14:
10874 case 15:
10875 case 16:
10876 case 17:
10877 case 18:
10878 case 19:
10879 case 20:
10880 case 21:
10881 case 22:
10882 case 23:
10883 case 24:
10884 case 28:
10885 case 29:
10886 case 30:
10887 case 31:
10888 {
10889 return 98;
10890 }
10891 case 32:
10892 case 33:
10893 {
10894 return 99;
10895 }
10896 case 37:
10897 {
10898 return 101;
10899 }
10900 default:
10901 {
10902 return -1;
10903 }
10904 }
10905 }
10906 case 16:
10907 {
10908 Lexeme prevMatch = token.match;
10909 token.match = lexeme;
10910 int tokenId = GetTokenId(5);
10911 if (tokenId == CONTINUE_TOKEN)
10912 {
10913 token.id = tokenId;
10914 return -1;
10915 }
10916 else if (tokenId != INVALID_TOKEN)
10917 {
10918 token.id = tokenId;
10919 }
10920 else
10921 {
10922 token.match = prevMatch;
10923 }
10924 switch (i)
10925 {
10926 case 3:
10927 case 7:
10928 case 8:
10929 case 9:
10930 case 10:
10931 case 11:
10932 case 12:
10933 case 13:
10934 case 34:
10935 case 35:
10936 case 36:
10937 case 38:
10938 case 39:
10939 case 40:
10940 case 41:
10941 case 42:
10942 case 43:
10943 case 44:
10944 case 45:
10945 case 46:
10946 case 47:
10947 case 48:
10948 case 49:
10949 case 50:
10950 case 51:
10951 case 52:
10952 case 53:
10953 case 54:
10954 case 55:
10955 {
10956 return 7;
10957 }
10958 case 0:
10959 {
10960 return 39;
10961 }
10962 case 1:
10963 {
10964 return 40;
10965 }
10966 case 4:
10967 {
10968 return 41;
10969 }
10970 case 2:
10971 {
10972 return 82;
10973 }
10974 case 5:
10975 case 6:
10976 case 14:
10977 case 15:
10978 case 16:
10979 case 17:
10980 case 18:
10981 case 19:
10982 case 20:
10983 case 21:
10984 case 22:
10985 case 23:
10986 case 24:
10987 case 25:
10988 case 26:
10989 case 27:
10990 case 28:
10991 case 29:
10992 case 30:
10993 case 31:
10994 case 32:
10995 case 33:
10996 {
10997 return 137;
10998 }
10999 case 37:
11000 {
11001 return 138;
11002 }
11003 default:
11004 {
11005 return -1;
11006 }
11007 }
11008 }
11009 case 138:
11010 {
11011 Lexeme prevMatch = token.match;
11012 token.match = lexeme;
11013 int tokenId = GetTokenId(5);
11014 if (tokenId == CONTINUE_TOKEN)
11015 {
11016 token.id = tokenId;
11017 return -1;
11018 }
11019 else if (tokenId != INVALID_TOKEN)
11020 {
11021 token.id = tokenId;
11022 }
11023 else
11024 {
11025 token.match = prevMatch;
11026 }
11027 switch (i)
11028 {
11029 case 2:
11030 case 3:
11031 case 7:
11032 case 8:
11033 case 9:
11034 case 10:
11035 case 11:
11036 case 12:
11037 case 13:
11038 case 34:
11039 case 35:
11040 case 36:
11041 case 37:
11042 case 38:
11043 case 39:
11044 case 40:
11045 case 41:
11046 case 42:
11047 case 43:
11048 case 44:
11049 case 45:
11050 case 46:
11051 case 47:
11052 case 48:
11053 case 49:
11054 case 50:
11055 case 51:
11056 case 52:
11057 case 53:
11058 case 54:
11059 case 55:
11060 {
11061 return 7;
11062 }
11063 case 0:
11064 {
11065 return 39;
11066 }
11067 case 1:
11068 {
11069 return 40;
11070 }
11071 case 4:
11072 {
11073 return 41;
11074 }
11075 case 5:
11076 case 6:
11077 case 14:
11078 case 15:
11079 case 16:
11080 case 17:
11081 case 18:
11082 case 19:
11083 case 20:
11084 case 21:
11085 case 22:
11086 case 23:
11087 case 24:
11088 case 25:
11089 case 26:
11090 case 27:
11091 case 28:
11092 case 29:
11093 case 30:
11094 case 31:
11095 case 32:
11096 case 33:
11097 {
11098 return 137;
11099 }
11100 default:
11101 {
11102 return -1;
11103 }
11104 }
11105 }
11106 case 137:
11107 {
11108 Lexeme prevMatch = token.match;
11109 token.match = lexeme;
11110 int tokenId = GetTokenId(5);
11111 if (tokenId == CONTINUE_TOKEN)
11112 {
11113 token.id = tokenId;
11114 return -1;
11115 }
11116 else if (tokenId != INVALID_TOKEN)
11117 {
11118 token.id = tokenId;
11119 }
11120 else
11121 {
11122 token.match = prevMatch;
11123 }
11124 switch (i)
11125 {
11126 case 2:
11127 case 3:
11128 case 7:
11129 case 8:
11130 case 9:
11131 case 10:
11132 case 11:
11133 case 12:
11134 case 13:
11135 case 34:
11136 case 35:
11137 case 36:
11138 case 38:
11139 case 39:
11140 case 40:
11141 case 41:
11142 case 42:
11143 case 43:
11144 case 44:
11145 case 45:
11146 case 46:
11147 case 47:
11148 case 48:
11149 case 49:
11150 case 50:
11151 case 51:
11152 case 52:
11153 case 53:
11154 case 54:
11155 case 55:
11156 {
11157 return 7;
11158 }
11159 case 0:
11160 {
11161 return 39;
11162 }
11163 case 1:
11164 {
11165 return 40;
11166 }
11167 case 4:
11168 {
11169 return 41;
11170 }
11171 case 5:
11172 case 6:
11173 case 14:
11174 case 15:
11175 case 16:
11176 case 17:
11177 case 18:
11178 case 19:
11179 case 20:
11180 case 21:
11181 case 22:
11182 case 23:
11183 case 24:
11184 case 25:
11185 case 26:
11186 case 27:
11187 case 28:
11188 case 29:
11189 case 30:
11190 case 31:
11191 case 32:
11192 case 33:
11193 {
11194 return 137;
11195 }
11196 case 37:
11197 {
11198 return 138;
11199 }
11200 default:
11201 {
11202 return -1;
11203 }
11204 }
11205 }
11206 case 15:
11207 {
11208 Lexeme prevMatch = token.match;
11209 token.match = lexeme;
11210 int tokenId = GetTokenId(5);
11211 if (tokenId == CONTINUE_TOKEN)
11212 {
11213 token.id = tokenId;
11214 return -1;
11215 }
11216 else if (tokenId != INVALID_TOKEN)
11217 {
11218 token.id = tokenId;
11219 }
11220 else
11221 {
11222 token.match = prevMatch;
11223 }
11224 switch (i)
11225 {
11226 case 2:
11227 {
11228 return 3;
11229 }
11230 case 3:
11231 case 7:
11232 case 8:
11233 case 10:
11234 case 11:
11235 case 12:
11236 case 13:
11237 case 34:
11238 case 35:
11239 case 36:
11240 case 38:
11241 case 39:
11242 case 40:
11243 case 41:
11244 case 42:
11245 case 43:
11246 case 44:
11247 case 45:
11248 case 46:
11249 case 47:
11250 case 48:
11251 case 49:
11252 case 50:
11253 case 51:
11254 case 52:
11255 case 53:
11256 case 54:
11257 case 55:
11258 {
11259 return 7;
11260 }
11261 case 9:
11262 {
11263 return 8;
11264 }
11265 case 0:
11266 {
11267 return 39;
11268 }
11269 case 1:
11270 {
11271 return 40;
11272 }
11273 case 4:
11274 {
11275 return 41;
11276 }
11277 case 5:
11278 case 6:
11279 case 14:
11280 case 15:
11281 case 16:
11282 case 17:
11283 case 18:
11284 case 19:
11285 case 20:
11286 case 21:
11287 case 22:
11288 case 24:
11289 case 25:
11290 case 26:
11291 case 27:
11292 case 28:
11293 case 29:
11294 case 30:
11295 case 31:
11296 case 32:
11297 case 33:
11298 {
11299 return 137;
11300 }
11301 case 23:
11302 {
11303 return 139;
11304 }
11305 case 37:
11306 {
11307 return 140;
11308 }
11309 default:
11310 {
11311 return -1;
11312 }
11313 }
11314 }
11315 case 140:
11316 {
11317 Lexeme prevMatch = token.match;
11318 token.match = lexeme;
11319 int tokenId = GetTokenId(5);
11320 if (tokenId == CONTINUE_TOKEN)
11321 {
11322 token.id = tokenId;
11323 return -1;
11324 }
11325 else if (tokenId != INVALID_TOKEN)
11326 {
11327 token.id = tokenId;
11328 }
11329 else
11330 {
11331 token.match = prevMatch;
11332 }
11333 switch (i)
11334 {
11335 case 2:
11336 {
11337 return 3;
11338 }
11339 case 3:
11340 case 7:
11341 case 8:
11342 case 9:
11343 case 10:
11344 case 11:
11345 case 12:
11346 case 13:
11347 case 34:
11348 case 35:
11349 case 36:
11350 case 37:
11351 case 38:
11352 case 39:
11353 case 40:
11354 case 41:
11355 case 42:
11356 case 43:
11357 case 44:
11358 case 45:
11359 case 46:
11360 case 47:
11361 case 48:
11362 case 49:
11363 case 50:
11364 case 51:
11365 case 52:
11366 case 53:
11367 case 54:
11368 case 55:
11369 {
11370 return 7;
11371 }
11372 case 0:
11373 {
11374 return 39;
11375 }
11376 case 1:
11377 {
11378 return 40;
11379 }
11380 case 4:
11381 {
11382 return 41;
11383 }
11384 case 5:
11385 case 6:
11386 case 14:
11387 case 15:
11388 case 16:
11389 case 17:
11390 case 18:
11391 case 19:
11392 case 20:
11393 case 21:
11394 case 22:
11395 case 24:
11396 case 25:
11397 case 26:
11398 case 27:
11399 case 28:
11400 case 29:
11401 case 30:
11402 case 31:
11403 case 32:
11404 case 33:
11405 {
11406 return 137;
11407 }
11408 case 23:
11409 {
11410 return 139;
11411 }
11412 default:
11413 {
11414 return -1;
11415 }
11416 }
11417 }
11418 case 139:
11419 {
11420 Lexeme prevMatch = token.match;
11421 token.match = lexeme;
11422 int tokenId = GetTokenId(5);
11423 if (tokenId == CONTINUE_TOKEN)
11424 {
11425 token.id = tokenId;
11426 return -1;
11427 }
11428 else if (tokenId != INVALID_TOKEN)
11429 {
11430 token.id = tokenId;
11431 }
11432 else
11433 {
11434 token.match = prevMatch;
11435 }
11436 switch (i)
11437 {
11438 case 3:
11439 case 7:
11440 case 8:
11441 case 9:
11442 case 10:
11443 case 11:
11444 case 12:
11445 case 13:
11446 case 34:
11447 case 35:
11448 case 36:
11449 case 38:
11450 case 39:
11451 case 40:
11452 case 41:
11453 case 42:
11454 case 43:
11455 case 44:
11456 case 45:
11457 case 46:
11458 case 47:
11459 case 48:
11460 case 49:
11461 case 50:
11462 case 51:
11463 case 52:
11464 case 53:
11465 case 54:
11466 case 55:
11467 {
11468 return 7;
11469 }
11470 case 0:
11471 {
11472 return 39;
11473 }
11474 case 1:
11475 {
11476 return 40;
11477 }
11478 case 4:
11479 {
11480 return 41;
11481 }
11482 case 2:
11483 {
11484 return 82;
11485 }
11486 case 5:
11487 case 6:
11488 case 14:
11489 case 15:
11490 case 16:
11491 case 17:
11492 case 18:
11493 case 19:
11494 case 20:
11495 case 21:
11496 case 22:
11497 case 23:
11498 case 24:
11499 case 25:
11500 case 26:
11501 case 27:
11502 case 28:
11503 case 29:
11504 case 30:
11505 case 31:
11506 case 32:
11507 case 33:
11508 {
11509 return 137;
11510 }
11511 case 37:
11512 {
11513 return 138;
11514 }
11515 default:
11516 {
11517 return -1;
11518 }
11519 }
11520 }
11521 case 14:
11522 {
11523 Lexeme prevMatch = token.match;
11524 token.match = lexeme;
11525 int tokenId = GetTokenId(5);
11526 if (tokenId == CONTINUE_TOKEN)
11527 {
11528 token.id = tokenId;
11529 return -1;
11530 }
11531 else if (tokenId != INVALID_TOKEN)
11532 {
11533 token.id = tokenId;
11534 }
11535 else
11536 {
11537 token.match = prevMatch;
11538 }
11539 switch (i)
11540 {
11541 case 2:
11542 {
11543 return 3;
11544 }
11545 case 3:
11546 case 7:
11547 case 8:
11548 case 10:
11549 case 11:
11550 case 12:
11551 case 13:
11552 case 34:
11553 case 35:
11554 case 36:
11555 case 38:
11556 case 39:
11557 case 40:
11558 case 41:
11559 case 42:
11560 case 43:
11561 case 44:
11562 case 45:
11563 case 46:
11564 case 47:
11565 case 48:
11566 case 49:
11567 case 50:
11568 case 51:
11569 case 52:
11570 case 53:
11571 case 54:
11572 case 55:
11573 {
11574 return 7;
11575 }
11576 case 9:
11577 {
11578 return 8;
11579 }
11580 case 0:
11581 {
11582 return 39;
11583 }
11584 case 1:
11585 {
11586 return 40;
11587 }
11588 case 4:
11589 {
11590 return 41;
11591 }
11592 case 5:
11593 case 6:
11594 case 14:
11595 case 15:
11596 case 16:
11597 case 17:
11598 case 18:
11599 case 19:
11600 case 20:
11601 case 21:
11602 case 22:
11603 case 24:
11604 case 25:
11605 case 26:
11606 case 27:
11607 case 28:
11608 case 29:
11609 case 30:
11610 case 31:
11611 case 32:
11612 case 33:
11613 {
11614 return 137;
11615 }
11616 case 23:
11617 {
11618 return 139;
11619 }
11620 case 37:
11621 {
11622 return 141;
11623 }
11624 default:
11625 {
11626 return -1;
11627 }
11628 }
11629 }
11630 case 141:
11631 {
11632 Lexeme prevMatch = token.match;
11633 token.match = lexeme;
11634 int tokenId = GetTokenId(5);
11635 if (tokenId == CONTINUE_TOKEN)
11636 {
11637 token.id = tokenId;
11638 return -1;
11639 }
11640 else if (tokenId != INVALID_TOKEN)
11641 {
11642 token.id = tokenId;
11643 }
11644 else
11645 {
11646 token.match = prevMatch;
11647 }
11648 switch (i)
11649 {
11650 case 2:
11651 {
11652 return 3;
11653 }
11654 case 3:
11655 case 7:
11656 case 8:
11657 case 9:
11658 case 10:
11659 case 11:
11660 case 12:
11661 case 13:
11662 case 34:
11663 case 35:
11664 case 36:
11665 case 38:
11666 case 39:
11667 case 40:
11668 case 41:
11669 case 42:
11670 case 43:
11671 case 44:
11672 case 45:
11673 case 46:
11674 case 47:
11675 case 48:
11676 case 49:
11677 case 50:
11678 case 51:
11679 case 52:
11680 case 53:
11681 case 54:
11682 case 55:
11683 {
11684 return 7;
11685 }
11686 case 0:
11687 {
11688 return 39;
11689 }
11690 case 1:
11691 {
11692 return 40;
11693 }
11694 case 4:
11695 {
11696 return 41;
11697 }
11698 case 37:
11699 {
11700 return 91;
11701 }
11702 case 5:
11703 case 6:
11704 case 14:
11705 case 15:
11706 case 16:
11707 case 17:
11708 case 18:
11709 case 19:
11710 case 20:
11711 case 21:
11712 case 22:
11713 case 24:
11714 case 25:
11715 case 26:
11716 case 27:
11717 case 28:
11718 case 29:
11719 case 30:
11720 case 31:
11721 case 32:
11722 case 33:
11723 {
11724 return 137;
11725 }
11726 case 23:
11727 {
11728 return 139;
11729 }
11730 default:
11731 {
11732 return -1;
11733 }
11734 }
11735 }
11736 case 13:
11737 {
11738 Lexeme prevMatch = token.match;
11739 token.match = lexeme;
11740 int tokenId = GetTokenId(5);
11741 if (tokenId == CONTINUE_TOKEN)
11742 {
11743 token.id = tokenId;
11744 return -1;
11745 }
11746 else if (tokenId != INVALID_TOKEN)
11747 {
11748 token.id = tokenId;
11749 }
11750 else
11751 {
11752 token.match = prevMatch;
11753 }
11754 switch (i)
11755 {
11756 case 2:
11757 {
11758 return 3;
11759 }
11760 case 3:
11761 case 7:
11762 case 8:
11763 case 10:
11764 case 11:
11765 case 12:
11766 case 13:
11767 case 34:
11768 case 35:
11769 case 36:
11770 case 38:
11771 case 39:
11772 case 40:
11773 case 41:
11774 case 42:
11775 case 43:
11776 case 44:
11777 case 45:
11778 case 46:
11779 case 47:
11780 case 48:
11781 case 49:
11782 case 50:
11783 case 51:
11784 case 52:
11785 case 53:
11786 case 54:
11787 case 55:
11788 {
11789 return 7;
11790 }
11791 case 9:
11792 {
11793 return 8;
11794 }
11795 case 0:
11796 {
11797 return 39;
11798 }
11799 case 1:
11800 {
11801 return 40;
11802 }
11803 case 4:
11804 {
11805 return 41;
11806 }
11807 case 5:
11808 case 6:
11809 case 14:
11810 case 15:
11811 case 16:
11812 case 17:
11813 case 18:
11814 case 19:
11815 case 20:
11816 case 21:
11817 case 22:
11818 case 24:
11819 case 25:
11820 case 27:
11821 case 28:
11822 case 29:
11823 case 30:
11824 case 31:
11825 case 32:
11826 case 33:
11827 {
11828 return 137;
11829 }
11830 case 23:
11831 {
11832 return 139;
11833 }
11834 case 26:
11835 {
11836 return 142;
11837 }
11838 case 37:
11839 {
11840 return 143;
11841 }
11842 default:
11843 {
11844 return -1;
11845 }
11846 }
11847 }
11848 case 143:
11849 {
11850 Lexeme prevMatch = token.match;
11851 token.match = lexeme;
11852 int tokenId = GetTokenId(5);
11853 if (tokenId == CONTINUE_TOKEN)
11854 {
11855 token.id = tokenId;
11856 return -1;
11857 }
11858 else if (tokenId != INVALID_TOKEN)
11859 {
11860 token.id = tokenId;
11861 }
11862 else
11863 {
11864 token.match = prevMatch;
11865 }
11866 switch (i)
11867 {
11868 case 2:
11869 {
11870 return 3;
11871 }
11872 case 3:
11873 case 7:
11874 case 8:
11875 case 9:
11876 case 10:
11877 case 11:
11878 case 12:
11879 case 13:
11880 case 34:
11881 case 35:
11882 case 36:
11883 case 38:
11884 case 39:
11885 case 40:
11886 case 41:
11887 case 42:
11888 case 43:
11889 case 44:
11890 case 45:
11891 case 46:
11892 case 47:
11893 case 48:
11894 case 49:
11895 case 50:
11896 case 51:
11897 case 52:
11898 case 53:
11899 case 54:
11900 case 55:
11901 {
11902 return 7;
11903 }
11904 case 0:
11905 {
11906 return 39;
11907 }
11908 case 1:
11909 {
11910 return 40;
11911 }
11912 case 4:
11913 {
11914 return 41;
11915 }
11916 case 37:
11917 {
11918 return 92;
11919 }
11920 case 5:
11921 case 6:
11922 case 14:
11923 case 15:
11924 case 16:
11925 case 17:
11926 case 18:
11927 case 19:
11928 case 20:
11929 case 21:
11930 case 22:
11931 case 24:
11932 case 25:
11933 case 26:
11934 case 27:
11935 case 28:
11936 case 29:
11937 case 30:
11938 case 31:
11939 case 32:
11940 case 33:
11941 {
11942 return 137;
11943 }
11944 case 23:
11945 {
11946 return 139;
11947 }
11948 default:
11949 {
11950 return -1;
11951 }
11952 }
11953 }
11954 case 142:
11955 {
11956 Lexeme prevMatch = token.match;
11957 token.match = lexeme;
11958 int tokenId = GetTokenId(5);
11959 if (tokenId == CONTINUE_TOKEN)
11960 {
11961 token.id = tokenId;
11962 return -1;
11963 }
11964 else if (tokenId != INVALID_TOKEN)
11965 {
11966 token.id = tokenId;
11967 }
11968 else
11969 {
11970 token.match = prevMatch;
11971 }
11972 switch (i)
11973 {
11974 case 2:
11975 {
11976 return 3;
11977 }
11978 case 3:
11979 case 7:
11980 case 8:
11981 case 9:
11982 case 10:
11983 case 11:
11984 case 12:
11985 case 13:
11986 case 34:
11987 case 35:
11988 case 36:
11989 case 38:
11990 case 39:
11991 case 40:
11992 case 41:
11993 case 42:
11994 case 43:
11995 case 44:
11996 case 45:
11997 case 46:
11998 case 47:
11999 case 48:
12000 case 49:
12001 case 50:
12002 case 51:
12003 case 52:
12004 case 53:
12005 case 54:
12006 case 55:
12007 {
12008 return 7;
12009 }
12010 case 0:
12011 {
12012 return 39;
12013 }
12014 case 1:
12015 {
12016 return 40;
12017 }
12018 case 4:
12019 {
12020 return 41;
12021 }
12022 case 5:
12023 case 6:
12024 case 14:
12025 case 15:
12026 case 16:
12027 case 17:
12028 case 18:
12029 case 19:
12030 case 20:
12031 case 21:
12032 case 22:
12033 case 24:
12034 case 25:
12035 case 26:
12036 case 27:
12037 case 28:
12038 case 29:
12039 case 30:
12040 case 31:
12041 case 32:
12042 case 33:
12043 {
12044 return 137;
12045 }
12046 case 23:
12047 {
12048 return 139;
12049 }
12050 case 37:
12051 {
12052 return 143;
12053 }
12054 default:
12055 {
12056 return -1;
12057 }
12058 }
12059 }
12060 case 12:
12061 {
12062 Lexeme prevMatch = token.match;
12063 token.match = lexeme;
12064 int tokenId = GetTokenId(40);
12065 if (tokenId == CONTINUE_TOKEN)
12066 {
12067 token.id = tokenId;
12068 return -1;
12069 }
12070 else if (tokenId != INVALID_TOKEN)
12071 {
12072 token.id = tokenId;
12073 }
12074 else
12075 {
12076 token.match = prevMatch;
12077 }
12078 switch (i)
12079 {
12080 case 2:
12081 case 3:
12082 case 5:
12083 case 6:
12084 case 7:
12085 case 8:
12086 case 9:
12087 case 10:
12088 case 11:
12089 case 12:
12090 case 14:
12091 case 15:
12092 case 16:
12093 case 17:
12094 case 18:
12095 case 19:
12096 case 20:
12097 case 21:
12098 case 22:
12099 case 23:
12100 case 24:
12101 case 25:
12102 case 26:
12103 case 27:
12104 case 28:
12105 case 29:
12106 case 30:
12107 case 31:
12108 case 32:
12109 case 33:
12110 case 34:
12111 case 35:
12112 case 36:
12113 case 37:
12114 case 38:
12115 case 39:
12116 case 41:
12117 case 43:
12118 case 44:
12119 case 45:
12120 case 46:
12121 case 47:
12122 case 48:
12123 case 49:
12124 case 50:
12125 case 51:
12126 case 52:
12127 case 53:
12128 case 54:
12129 case 55:
12130 {
12131 return 7;
12132 }
12133 case 0:
12134 {
12135 return 39;
12136 }
12137 case 1:
12138 {
12139 return 40;
12140 }
12141 case 4:
12142 {
12143 return 41;
12144 }
12145 case 13:
12146 {
12147 return 144;
12148 }
12149 case 40:
12150 {
12151 return 145;
12152 }
12153 case 42:
12154 {
12155 return 146;
12156 }
12157 default:
12158 {
12159 return -1;
12160 }
12161 }
12162 }
12163 case 146:
12164 {
12165 Lexeme prevMatch = token.match;
12166 token.match = lexeme;
12167 int tokenId = GetTokenId(55);
12168 if (tokenId == CONTINUE_TOKEN)
12169 {
12170 token.id = tokenId;
12171 return -1;
12172 }
12173 else if (tokenId != INVALID_TOKEN)
12174 {
12175 token.id = tokenId;
12176 }
12177 else
12178 {
12179 token.match = prevMatch;
12180 }
12181 switch (i)
12182 {
12183 case 2:
12184 case 3:
12185 case 5:
12186 case 6:
12187 case 7:
12188 case 8:
12189 case 9:
12190 case 10:
12191 case 11:
12192 case 12:
12193 case 13:
12194 case 14:
12195 case 15:
12196 case 16:
12197 case 17:
12198 case 18:
12199 case 19:
12200 case 20:
12201 case 21:
12202 case 22:
12203 case 23:
12204 case 24:
12205 case 25:
12206 case 26:
12207 case 27:
12208 case 28:
12209 case 29:
12210 case 30:
12211 case 31:
12212 case 32:
12213 case 33:
12214 case 34:
12215 case 35:
12216 case 36:
12217 case 37:
12218 case 38:
12219 case 39:
12220 case 40:
12221 case 41:
12222 case 42:
12223 case 43:
12224 case 44:
12225 case 45:
12226 case 46:
12227 case 47:
12228 case 48:
12229 case 49:
12230 case 50:
12231 case 51:
12232 case 52:
12233 case 53:
12234 case 54:
12235 case 55:
12236 {
12237 return 7;
12238 }
12239 case 0:
12240 {
12241 return 39;
12242 }
12243 case 1:
12244 {
12245 return 40;
12246 }
12247 case 4:
12248 {
12249 return 147;
12250 }
12251 default:
12252 {
12253 return -1;
12254 }
12255 }
12256 }
12257 case 147:
12258 {
12259 Lexeme prevMatch = token.match;
12260 token.match = lexeme;
12261 int tokenId = GetTokenId(45);
12262 if (tokenId == CONTINUE_TOKEN)
12263 {
12264 token.id = tokenId;
12265 return -1;
12266 }
12267 else if (tokenId != INVALID_TOKEN)
12268 {
12269 token.id = tokenId;
12270 }
12271 else
12272 {
12273 token.match = prevMatch;
12274 }
12275 switch (i)
12276 {
12277 case 0:
12278 {
12279 return 39;
12280 }
12281 case 1:
12282 {
12283 return 40;
12284 }
12285 case 4:
12286 {
12287 return 41;
12288 }
12289 case 2:
12290 case 5:
12291 case 6:
12292 case 7:
12293 case 8:
12294 case 9:
12295 case 10:
12296 case 11:
12297 case 12:
12298 case 13:
12299 case 14:
12300 case 15:
12301 case 16:
12302 case 17:
12303 case 18:
12304 case 19:
12305 case 20:
12306 case 21:
12307 case 22:
12308 case 23:
12309 case 24:
12310 case 25:
12311 case 26:
12312 case 27:
12313 case 28:
12314 case 29:
12315 case 30:
12316 case 31:
12317 case 32:
12318 case 33:
12319 case 34:
12320 case 35:
12321 case 36:
12322 case 37:
12323 case 38:
12324 case 39:
12325 case 40:
12326 case 41:
12327 case 42:
12328 case 43:
12329 case 44:
12330 case 45:
12331 case 46:
12332 case 47:
12333 case 48:
12334 case 49:
12335 case 50:
12336 case 51:
12337 case 52:
12338 case 53:
12339 case 54:
12340 case 55:
12341 {
12342 return 42;
12343 }
12344 case 3:
12345 {
12346 return 43;
12347 }
12348 default:
12349 {
12350 return -1;
12351 }
12352 }
12353 }
12354 case 145:
12355 {
12356 Lexeme prevMatch = token.match;
12357 token.match = lexeme;
12358 int tokenId = GetTokenId(17);
12359 if (tokenId == CONTINUE_TOKEN)
12360 {
12361 token.id = tokenId;
12362 return -1;
12363 }
12364 else if (tokenId != INVALID_TOKEN)
12365 {
12366 token.id = tokenId;
12367 }
12368 else
12369 {
12370 token.match = prevMatch;
12371 }
12372 switch (i)
12373 {
12374 case 2:
12375 case 3:
12376 case 5:
12377 case 6:
12378 case 7:
12379 case 8:
12380 case 9:
12381 case 10:
12382 case 11:
12383 case 12:
12384 case 13:
12385 case 14:
12386 case 15:
12387 case 16:
12388 case 17:
12389 case 18:
12390 case 19:
12391 case 20:
12392 case 21:
12393 case 22:
12394 case 23:
12395 case 24:
12396 case 25:
12397 case 26:
12398 case 27:
12399 case 28:
12400 case 29:
12401 case 30:
12402 case 31:
12403 case 32:
12404 case 33:
12405 case 34:
12406 case 35:
12407 case 36:
12408 case 37:
12409 case 38:
12410 case 39:
12411 case 40:
12412 case 41:
12413 case 42:
12414 case 43:
12415 case 44:
12416 case 45:
12417 case 46:
12418 case 47:
12419 case 48:
12420 case 49:
12421 case 50:
12422 case 51:
12423 case 52:
12424 case 53:
12425 case 54:
12426 case 55:
12427 {
12428 return 7;
12429 }
12430 case 0:
12431 {
12432 return 39;
12433 }
12434 case 1:
12435 {
12436 return 40;
12437 }
12438 case 4:
12439 {
12440 return 41;
12441 }
12442 default:
12443 {
12444 return -1;
12445 }
12446 }
12447 }
12448 case 144:
12449 {
12450 Lexeme prevMatch = token.match;
12451 token.match = lexeme;
12452 int tokenId = GetTokenId(49);
12453 if (tokenId == CONTINUE_TOKEN)
12454 {
12455 token.id = tokenId;
12456 return -1;
12457 }
12458 else if (tokenId != INVALID_TOKEN)
12459 {
12460 token.id = tokenId;
12461 }
12462 else
12463 {
12464 token.match = prevMatch;
12465 }
12466 switch (i)
12467 {
12468 case 2:
12469 case 3:
12470 case 5:
12471 case 6:
12472 case 7:
12473 case 8:
12474 case 9:
12475 case 10:
12476 case 11:
12477 case 12:
12478 case 13:
12479 case 14:
12480 case 15:
12481 case 16:
12482 case 17:
12483 case 18:
12484 case 19:
12485 case 20:
12486 case 21:
12487 case 22:
12488 case 23:
12489 case 24:
12490 case 25:
12491 case 26:
12492 case 27:
12493 case 28:
12494 case 29:
12495 case 30:
12496 case 31:
12497 case 32:
12498 case 33:
12499 case 34:
12500 case 35:
12501 case 36:
12502 case 37:
12503 case 38:
12504 case 39:
12505 case 40:
12506 case 41:
12507 case 42:
12508 case 43:
12509 case 44:
12510 case 45:
12511 case 46:
12512 case 47:
12513 case 48:
12514 case 49:
12515 case 50:
12516 case 51:
12517 case 52:
12518 case 53:
12519 case 54:
12520 case 55:
12521 {
12522 return 7;
12523 }
12524 case 0:
12525 {
12526 return 39;
12527 }
12528 case 1:
12529 {
12530 return 40;
12531 }
12532 case 4:
12533 {
12534 return 41;
12535 }
12536 default:
12537 {
12538 return -1;
12539 }
12540 }
12541 }
12542 case 11:
12543 {
12544 Lexeme prevMatch = token.match;
12545 token.match = lexeme;
12546 int tokenId = GetTokenId(39);
12547 if (tokenId == CONTINUE_TOKEN)
12548 {
12549 token.id = tokenId;
12550 return -1;
12551 }
12552 else if (tokenId != INVALID_TOKEN)
12553 {
12554 token.id = tokenId;
12555 }
12556 else
12557 {
12558 token.match = prevMatch;
12559 }
12560 switch (i)
12561 {
12562 case 2:
12563 case 3:
12564 case 5:
12565 case 6:
12566 case 7:
12567 case 8:
12568 case 9:
12569 case 10:
12570 case 11:
12571 case 13:
12572 case 14:
12573 case 15:
12574 case 16:
12575 case 17:
12576 case 18:
12577 case 19:
12578 case 20:
12579 case 21:
12580 case 22:
12581 case 23:
12582 case 24:
12583 case 25:
12584 case 26:
12585 case 27:
12586 case 28:
12587 case 29:
12588 case 30:
12589 case 31:
12590 case 32:
12591 case 33:
12592 case 34:
12593 case 35:
12594 case 36:
12595 case 37:
12596 case 38:
12597 case 39:
12598 case 41:
12599 case 42:
12600 case 43:
12601 case 44:
12602 case 45:
12603 case 46:
12604 case 47:
12605 case 48:
12606 case 49:
12607 case 50:
12608 case 51:
12609 case 52:
12610 case 53:
12611 case 54:
12612 case 55:
12613 {
12614 return 7;
12615 }
12616 case 0:
12617 {
12618 return 39;
12619 }
12620 case 1:
12621 {
12622 return 40;
12623 }
12624 case 4:
12625 {
12626 return 41;
12627 }
12628 case 12:
12629 {
12630 return 148;
12631 }
12632 case 40:
12633 {
12634 return 149;
12635 }
12636 default:
12637 {
12638 return -1;
12639 }
12640 }
12641 }
12642 case 149:
12643 {
12644 Lexeme prevMatch = token.match;
12645 token.match = lexeme;
12646 int tokenId = GetTokenId(16);
12647 if (tokenId == CONTINUE_TOKEN)
12648 {
12649 token.id = tokenId;
12650 return -1;
12651 }
12652 else if (tokenId != INVALID_TOKEN)
12653 {
12654 token.id = tokenId;
12655 }
12656 else
12657 {
12658 token.match = prevMatch;
12659 }
12660 switch (i)
12661 {
12662 case 2:
12663 case 3:
12664 case 5:
12665 case 6:
12666 case 7:
12667 case 8:
12668 case 9:
12669 case 10:
12670 case 11:
12671 case 12:
12672 case 13:
12673 case 14:
12674 case 15:
12675 case 16:
12676 case 17:
12677 case 18:
12678 case 19:
12679 case 20:
12680 case 21:
12681 case 22:
12682 case 23:
12683 case 24:
12684 case 25:
12685 case 26:
12686 case 27:
12687 case 28:
12688 case 29:
12689 case 30:
12690 case 31:
12691 case 32:
12692 case 33:
12693 case 34:
12694 case 35:
12695 case 36:
12696 case 37:
12697 case 38:
12698 case 39:
12699 case 40:
12700 case 41:
12701 case 42:
12702 case 43:
12703 case 44:
12704 case 45:
12705 case 46:
12706 case 47:
12707 case 48:
12708 case 49:
12709 case 50:
12710 case 51:
12711 case 52:
12712 case 53:
12713 case 54:
12714 case 55:
12715 {
12716 return 7;
12717 }
12718 case 0:
12719 {
12720 return 39;
12721 }
12722 case 1:
12723 {
12724 return 40;
12725 }
12726 case 4:
12727 {
12728 return 41;
12729 }
12730 default:
12731 {
12732 return -1;
12733 }
12734 }
12735 }
12736 case 148:
12737 {
12738 Lexeme prevMatch = token.match;
12739 token.match = lexeme;
12740 int tokenId = GetTokenId(48);
12741 if (tokenId == CONTINUE_TOKEN)
12742 {
12743 token.id = tokenId;
12744 return -1;
12745 }
12746 else if (tokenId != INVALID_TOKEN)
12747 {
12748 token.id = tokenId;
12749 }
12750 else
12751 {
12752 token.match = prevMatch;
12753 }
12754 switch (i)
12755 {
12756 case 2:
12757 case 3:
12758 case 5:
12759 case 6:
12760 case 7:
12761 case 8:
12762 case 9:
12763 case 10:
12764 case 11:
12765 case 12:
12766 case 13:
12767 case 14:
12768 case 15:
12769 case 16:
12770 case 17:
12771 case 18:
12772 case 19:
12773 case 20:
12774 case 21:
12775 case 22:
12776 case 23:
12777 case 24:
12778 case 25:
12779 case 26:
12780 case 27:
12781 case 28:
12782 case 29:
12783 case 30:
12784 case 31:
12785 case 32:
12786 case 33:
12787 case 34:
12788 case 35:
12789 case 36:
12790 case 37:
12791 case 38:
12792 case 39:
12793 case 40:
12794 case 41:
12795 case 42:
12796 case 43:
12797 case 44:
12798 case 45:
12799 case 46:
12800 case 47:
12801 case 48:
12802 case 49:
12803 case 50:
12804 case 51:
12805 case 52:
12806 case 53:
12807 case 54:
12808 case 55:
12809 {
12810 return 7;
12811 }
12812 case 0:
12813 {
12814 return 39;
12815 }
12816 case 1:
12817 {
12818 return 40;
12819 }
12820 case 4:
12821 {
12822 return 41;
12823 }
12824 default:
12825 {
12826 return -1;
12827 }
12828 }
12829 }
12830 case 10:
12831 {
12832 Lexeme prevMatch = token.match;
12833 token.match = lexeme;
12834 int tokenId = GetTokenId(54);
12835 if (tokenId == CONTINUE_TOKEN)
12836 {
12837 token.id = tokenId;
12838 return -1;
12839 }
12840 else if (tokenId != INVALID_TOKEN)
12841 {
12842 token.id = tokenId;
12843 }
12844 else
12845 {
12846 token.match = prevMatch;
12847 }
12848 switch (i)
12849 {
12850 case 2:
12851 case 3:
12852 case 5:
12853 case 6:
12854 case 7:
12855 case 8:
12856 case 9:
12857 case 10:
12858 case 12:
12859 case 13:
12860 case 14:
12861 case 15:
12862 case 16:
12863 case 17:
12864 case 18:
12865 case 19:
12866 case 20:
12867 case 21:
12868 case 22:
12869 case 23:
12870 case 24:
12871 case 28:
12872 case 29:
12873 case 30:
12874 case 31:
12875 case 32:
12876 case 33:
12877 case 34:
12878 case 35:
12879 case 36:
12880 case 38:
12881 case 39:
12882 case 40:
12883 case 41:
12884 case 42:
12885 case 43:
12886 case 44:
12887 case 45:
12888 case 46:
12889 case 47:
12890 case 48:
12891 case 49:
12892 case 50:
12893 case 51:
12894 case 52:
12895 case 53:
12896 case 54:
12897 case 55:
12898 {
12899 return 7;
12900 }
12901 case 0:
12902 {
12903 return 39;
12904 }
12905 case 1:
12906 {
12907 return 40;
12908 }
12909 case 25:
12910 case 26:
12911 case 27:
12912 {
12913 return 95;
12914 }
12915 case 37:
12916 {
12917 return 96;
12918 }
12919 case 4:
12920 {
12921 return 150;
12922 }
12923 case 11:
12924 {
12925 return 151;
12926 }
12927 default:
12928 {
12929 return -1;
12930 }
12931 }
12932 }
12933 case 151:
12934 {
12935 switch (i)
12936 {
12937 case 2:
12938 case 3:
12939 case 5:
12940 case 6:
12941 case 7:
12942 case 8:
12943 case 9:
12944 case 10:
12945 case 12:
12946 case 13:
12947 case 14:
12948 case 15:
12949 case 16:
12950 case 17:
12951 case 18:
12952 case 19:
12953 case 20:
12954 case 21:
12955 case 22:
12956 case 23:
12957 case 24:
12958 case 25:
12959 case 26:
12960 case 27:
12961 case 28:
12962 case 29:
12963 case 30:
12964 case 31:
12965 case 32:
12966 case 33:
12967 case 34:
12968 case 35:
12969 case 36:
12970 case 37:
12971 case 38:
12972 case 39:
12973 case 40:
12974 case 41:
12975 case 42:
12976 case 43:
12977 case 44:
12978 case 45:
12979 case 46:
12980 case 47:
12981 case 48:
12982 case 49:
12983 case 50:
12984 case 51:
12985 case 52:
12986 case 53:
12987 case 54:
12988 case 55:
12989 {
12990 return 7;
12991 }
12992 case 0:
12993 {
12994 return 39;
12995 }
12996 case 1:
12997 {
12998 return 40;
12999 }
13000 case 4:
13001 {
13002 return 41;
13003 }
13004 case 11:
13005 {
13006 return 152;
13007 }
13008 default:
13009 {
13010 return -1;
13011 }
13012 }
13013 }
13014 case 152:
13015 {
13016 Lexeme prevMatch = token.match;
13017 token.match = lexeme;
13018 int tokenId = GetTokenId(57);
13019 if (tokenId == CONTINUE_TOKEN)
13020 {
13021 token.id = tokenId;
13022 return -1;
13023 }
13024 else if (tokenId != INVALID_TOKEN)
13025 {
13026 token.id = tokenId;
13027 }
13028 else
13029 {
13030 token.match = prevMatch;
13031 }
13032 switch (i)
13033 {
13034 case 2:
13035 case 3:
13036 case 5:
13037 case 6:
13038 case 7:
13039 case 8:
13040 case 9:
13041 case 10:
13042 case 11:
13043 case 12:
13044 case 13:
13045 case 14:
13046 case 15:
13047 case 16:
13048 case 17:
13049 case 18:
13050 case 19:
13051 case 20:
13052 case 21:
13053 case 22:
13054 case 23:
13055 case 24:
13056 case 25:
13057 case 26:
13058 case 27:
13059 case 28:
13060 case 29:
13061 case 30:
13062 case 31:
13063 case 32:
13064 case 33:
13065 case 34:
13066 case 35:
13067 case 36:
13068 case 37:
13069 case 38:
13070 case 39:
13071 case 40:
13072 case 41:
13073 case 42:
13074 case 43:
13075 case 44:
13076 case 45:
13077 case 46:
13078 case 47:
13079 case 48:
13080 case 49:
13081 case 50:
13082 case 51:
13083 case 52:
13084 case 53:
13085 case 54:
13086 case 55:
13087 {
13088 return 7;
13089 }
13090 case 0:
13091 {
13092 return 39;
13093 }
13094 case 1:
13095 {
13096 return 40;
13097 }
13098 case 4:
13099 {
13100 return 41;
13101 }
13102 default:
13103 {
13104 return -1;
13105 }
13106 }
13107 }
13108 case 150:
13109 {
13110 Lexeme prevMatch = token.match;
13111 token.match = lexeme;
13112 int tokenId = GetTokenId(44);
13113 if (tokenId == CONTINUE_TOKEN)
13114 {
13115 token.id = tokenId;
13116 return -1;
13117 }
13118 else if (tokenId != INVALID_TOKEN)
13119 {
13120 token.id = tokenId;
13121 }
13122 else
13123 {
13124 token.match = prevMatch;
13125 }
13126 switch (i)
13127 {
13128 case 0:
13129 {
13130 return 39;
13131 }
13132 case 1:
13133 {
13134 return 40;
13135 }
13136 case 4:
13137 {
13138 return 41;
13139 }
13140 case 2:
13141 case 5:
13142 case 6:
13143 case 7:
13144 case 8:
13145 case 9:
13146 case 10:
13147 case 11:
13148 case 12:
13149 case 13:
13150 case 14:
13151 case 15:
13152 case 16:
13153 case 17:
13154 case 18:
13155 case 19:
13156 case 20:
13157 case 21:
13158 case 22:
13159 case 23:
13160 case 24:
13161 case 25:
13162 case 26:
13163 case 27:
13164 case 28:
13165 case 29:
13166 case 30:
13167 case 31:
13168 case 32:
13169 case 33:
13170 case 34:
13171 case 35:
13172 case 36:
13173 case 37:
13174 case 38:
13175 case 39:
13176 case 40:
13177 case 41:
13178 case 42:
13179 case 43:
13180 case 44:
13181 case 45:
13182 case 46:
13183 case 47:
13184 case 48:
13185 case 49:
13186 case 50:
13187 case 51:
13188 case 52:
13189 case 53:
13190 case 54:
13191 case 55:
13192 {
13193 return 42;
13194 }
13195 case 3:
13196 {
13197 return 43;
13198 }
13199 default:
13200 {
13201 return -1;
13202 }
13203 }
13204 }
13205 case 9:
13206 {
13207 Lexeme prevMatch = token.match;
13208 token.match = lexeme;
13209 int tokenId = GetTokenId(23);
13210 if (tokenId == CONTINUE_TOKEN)
13211 {
13212 token.id = tokenId;
13213 return -1;
13214 }
13215 else if (tokenId != INVALID_TOKEN)
13216 {
13217 token.id = tokenId;
13218 }
13219 else
13220 {
13221 token.match = prevMatch;
13222 }
13223 switch (i)
13224 {
13225 case 2:
13226 case 3:
13227 case 5:
13228 case 6:
13229 case 7:
13230 case 8:
13231 case 9:
13232 case 10:
13233 case 11:
13234 case 12:
13235 case 13:
13236 case 14:
13237 case 15:
13238 case 16:
13239 case 17:
13240 case 18:
13241 case 19:
13242 case 20:
13243 case 21:
13244 case 22:
13245 case 23:
13246 case 24:
13247 case 25:
13248 case 26:
13249 case 27:
13250 case 28:
13251 case 29:
13252 case 30:
13253 case 31:
13254 case 32:
13255 case 33:
13256 case 34:
13257 case 35:
13258 case 36:
13259 case 37:
13260 case 38:
13261 case 39:
13262 case 40:
13263 case 41:
13264 case 42:
13265 case 43:
13266 case 44:
13267 case 45:
13268 case 46:
13269 case 47:
13270 case 48:
13271 case 49:
13272 case 50:
13273 case 51:
13274 case 52:
13275 case 53:
13276 case 54:
13277 case 55:
13278 {
13279 return 7;
13280 }
13281 case 0:
13282 {
13283 return 39;
13284 }
13285 case 1:
13286 {
13287 return 40;
13288 }
13289 case 4:
13290 {
13291 return 41;
13292 }
13293 default:
13294 {
13295 return -1;
13296 }
13297 }
13298 }
13299 case 8:
13300 {
13301 switch (i)
13302 {
13303 case 0:
13304 {
13305 return 39;
13306 }
13307 case 1:
13308 {
13309 return 40;
13310 }
13311 case 2:
13312 case 3:
13313 case 5:
13314 case 6:
13315 case 7:
13316 case 10:
13317 case 11:
13318 case 12:
13319 case 13:
13320 case 14:
13321 case 15:
13322 case 16:
13323 case 17:
13324 case 18:
13325 case 19:
13326 case 20:
13327 case 21:
13328 case 22:
13329 case 23:
13330 case 24:
13331 case 25:
13332 case 26:
13333 case 27:
13334 case 28:
13335 case 29:
13336 case 30:
13337 case 31:
13338 case 32:
13339 case 33:
13340 case 34:
13341 case 35:
13342 case 36:
13343 case 37:
13344 case 38:
13345 case 39:
13346 case 40:
13347 case 41:
13348 case 42:
13349 case 43:
13350 case 44:
13351 case 45:
13352 case 46:
13353 case 47:
13354 case 48:
13355 case 49:
13356 case 50:
13357 case 51:
13358 case 52:
13359 case 53:
13360 case 54:
13361 case 55:
13362 {
13363 return 153;
13364 }
13365 case 4:
13366 {
13367 return 154;
13368 }
13369 case 8:
13370 {
13371 return 155;
13372 }
13373 case 9:
13374 {
13375 return 156;
13376 }
13377 default:
13378 {
13379 return -1;
13380 }
13381 }
13382 }
13383 case 156:
13384 {
13385 Lexeme prevMatch = token.match;
13386 token.match = lexeme;
13387 int tokenId = GetTokenId(6);
13388 if (tokenId == CONTINUE_TOKEN)
13389 {
13390 token.id = tokenId;
13391 return -1;
13392 }
13393 else if (tokenId != INVALID_TOKEN)
13394 {
13395 token.id = tokenId;
13396 }
13397 else
13398 {
13399 token.match = prevMatch;
13400 }
13401 switch (i)
13402 {
13403 case 2:
13404 case 3:
13405 case 5:
13406 case 6:
13407 case 7:
13408 case 8:
13409 case 9:
13410 case 10:
13411 case 11:
13412 case 12:
13413 case 13:
13414 case 14:
13415 case 15:
13416 case 16:
13417 case 17:
13418 case 18:
13419 case 19:
13420 case 20:
13421 case 21:
13422 case 22:
13423 case 23:
13424 case 24:
13425 case 25:
13426 case 26:
13427 case 27:
13428 case 28:
13429 case 29:
13430 case 30:
13431 case 31:
13432 case 32:
13433 case 33:
13434 case 34:
13435 case 35:
13436 case 36:
13437 case 37:
13438 case 38:
13439 case 39:
13440 case 40:
13441 case 41:
13442 case 42:
13443 case 43:
13444 case 44:
13445 case 45:
13446 case 46:
13447 case 47:
13448 case 48:
13449 case 49:
13450 case 50:
13451 case 51:
13452 case 52:
13453 case 53:
13454 case 54:
13455 case 55:
13456 {
13457 return 7;
13458 }
13459 case 0:
13460 {
13461 return 39;
13462 }
13463 case 1:
13464 {
13465 return 40;
13466 }
13467 case 4:
13468 {
13469 return 41;
13470 }
13471 default:
13472 {
13473 return -1;
13474 }
13475 }
13476 }
13477 case 155:
13478 {
13479 switch (i)
13480 {
13481 case 3:
13482 case 5:
13483 case 6:
13484 case 7:
13485 case 11:
13486 case 12:
13487 case 13:
13488 case 14:
13489 case 17:
13490 case 23:
13491 case 24:
13492 case 25:
13493 case 26:
13494 case 28:
13495 case 32:
13496 case 33:
13497 case 34:
13498 case 35:
13499 case 36:
13500 case 37:
13501 case 38:
13502 case 39:
13503 case 40:
13504 case 41:
13505 case 42:
13506 case 43:
13507 case 44:
13508 case 45:
13509 case 46:
13510 case 47:
13511 case 48:
13512 case 49:
13513 case 50:
13514 case 51:
13515 case 52:
13516 case 53:
13517 case 54:
13518 case 55:
13519 {
13520 return 7;
13521 }
13522 case 0:
13523 {
13524 return 39;
13525 }
13526 case 1:
13527 {
13528 return 40;
13529 }
13530 case 4:
13531 {
13532 return 41;
13533 }
13534 case 2:
13535 case 8:
13536 case 9:
13537 case 10:
13538 case 19:
13539 case 20:
13540 case 21:
13541 case 22:
13542 case 29:
13543 case 30:
13544 case 31:
13545 {
13546 return 157;
13547 }
13548 case 15:
13549 {
13550 return 158;
13551 }
13552 case 16:
13553 {
13554 return 159;
13555 }
13556 case 18:
13557 {
13558 return 160;
13559 }
13560 case 27:
13561 {
13562 return 161;
13563 }
13564 default:
13565 {
13566 return -1;
13567 }
13568 }
13569 }
13570 case 161:
13571 {
13572 switch (i)
13573 {
13574 case 0:
13575 {
13576 return 39;
13577 }
13578 case 1:
13579 {
13580 return 40;
13581 }
13582 case 2:
13583 case 3:
13584 case 5:
13585 case 6:
13586 case 7:
13587 case 10:
13588 case 11:
13589 case 12:
13590 case 13:
13591 case 14:
13592 case 15:
13593 case 16:
13594 case 17:
13595 case 18:
13596 case 19:
13597 case 20:
13598 case 21:
13599 case 22:
13600 case 23:
13601 case 24:
13602 case 25:
13603 case 26:
13604 case 28:
13605 case 29:
13606 case 30:
13607 case 31:
13608 case 32:
13609 case 33:
13610 case 34:
13611 case 35:
13612 case 36:
13613 case 38:
13614 case 39:
13615 case 40:
13616 case 41:
13617 case 42:
13618 case 43:
13619 case 44:
13620 case 45:
13621 case 46:
13622 case 47:
13623 case 48:
13624 case 49:
13625 case 50:
13626 case 51:
13627 case 52:
13628 case 53:
13629 case 54:
13630 case 55:
13631 {
13632 return 153;
13633 }
13634 case 4:
13635 {
13636 return 154;
13637 }
13638 case 8:
13639 {
13640 return 155;
13641 }
13642 case 9:
13643 {
13644 return 156;
13645 }
13646 case 27:
13647 {
13648 return 162;
13649 }
13650 case 37:
13651 {
13652 return 163;
13653 }
13654 default:
13655 {
13656 return -1;
13657 }
13658 }
13659 }
13660 case 163:
13661 {
13662 switch (i)
13663 {
13664 case 0:
13665 {
13666 return 39;
13667 }
13668 case 1:
13669 {
13670 return 40;
13671 }
13672 case 2:
13673 case 3:
13674 case 5:
13675 case 6:
13676 case 7:
13677 case 10:
13678 case 11:
13679 case 12:
13680 case 13:
13681 case 14:
13682 case 15:
13683 case 16:
13684 case 17:
13685 case 18:
13686 case 19:
13687 case 20:
13688 case 21:
13689 case 22:
13690 case 23:
13691 case 24:
13692 case 25:
13693 case 26:
13694 case 27:
13695 case 28:
13696 case 29:
13697 case 30:
13698 case 31:
13699 case 32:
13700 case 33:
13701 case 34:
13702 case 35:
13703 case 36:
13704 case 38:
13705 case 39:
13706 case 40:
13707 case 41:
13708 case 42:
13709 case 43:
13710 case 44:
13711 case 45:
13712 case 46:
13713 case 47:
13714 case 48:
13715 case 49:
13716 case 50:
13717 case 51:
13718 case 52:
13719 case 53:
13720 case 54:
13721 case 55:
13722 {
13723 return 153;
13724 }
13725 case 4:
13726 {
13727 return 154;
13728 }
13729 case 8:
13730 {
13731 return 155;
13732 }
13733 case 9:
13734 {
13735 return 156;
13736 }
13737 case 37:
13738 {
13739 return 164;
13740 }
13741 default:
13742 {
13743 return -1;
13744 }
13745 }
13746 }
13747 case 164:
13748 {
13749 switch (i)
13750 {
13751 case 0:
13752 {
13753 return 39;
13754 }
13755 case 1:
13756 {
13757 return 40;
13758 }
13759 case 2:
13760 case 3:
13761 case 5:
13762 case 6:
13763 case 7:
13764 case 10:
13765 case 11:
13766 case 12:
13767 case 13:
13768 case 14:
13769 case 15:
13770 case 16:
13771 case 17:
13772 case 18:
13773 case 19:
13774 case 20:
13775 case 21:
13776 case 22:
13777 case 23:
13778 case 24:
13779 case 25:
13780 case 26:
13781 case 27:
13782 case 28:
13783 case 29:
13784 case 30:
13785 case 31:
13786 case 32:
13787 case 33:
13788 case 34:
13789 case 35:
13790 case 36:
13791 case 38:
13792 case 39:
13793 case 40:
13794 case 41:
13795 case 42:
13796 case 43:
13797 case 44:
13798 case 45:
13799 case 46:
13800 case 47:
13801 case 48:
13802 case 49:
13803 case 50:
13804 case 51:
13805 case 52:
13806 case 53:
13807 case 54:
13808 case 55:
13809 {
13810 return 153;
13811 }
13812 case 4:
13813 {
13814 return 154;
13815 }
13816 case 8:
13817 {
13818 return 155;
13819 }
13820 case 9:
13821 {
13822 return 156;
13823 }
13824 case 37:
13825 {
13826 return 165;
13827 }
13828 default:
13829 {
13830 return -1;
13831 }
13832 }
13833 }
13834 case 165:
13835 {
13836 switch (i)
13837 {
13838 case 0:
13839 {
13840 return 39;
13841 }
13842 case 1:
13843 {
13844 return 40;
13845 }
13846 case 2:
13847 case 3:
13848 case 5:
13849 case 6:
13850 case 7:
13851 case 10:
13852 case 11:
13853 case 12:
13854 case 13:
13855 case 14:
13856 case 15:
13857 case 16:
13858 case 17:
13859 case 18:
13860 case 19:
13861 case 20:
13862 case 21:
13863 case 22:
13864 case 23:
13865 case 24:
13866 case 25:
13867 case 26:
13868 case 27:
13869 case 28:
13870 case 29:
13871 case 30:
13872 case 31:
13873 case 32:
13874 case 33:
13875 case 34:
13876 case 35:
13877 case 36:
13878 case 38:
13879 case 39:
13880 case 40:
13881 case 41:
13882 case 42:
13883 case 43:
13884 case 44:
13885 case 45:
13886 case 46:
13887 case 47:
13888 case 48:
13889 case 49:
13890 case 50:
13891 case 51:
13892 case 52:
13893 case 53:
13894 case 54:
13895 case 55:
13896 {
13897 return 153;
13898 }
13899 case 4:
13900 {
13901 return 154;
13902 }
13903 case 8:
13904 {
13905 return 155;
13906 }
13907 case 9:
13908 {
13909 return 156;
13910 }
13911 case 37:
13912 {
13913 return 166;
13914 }
13915 default:
13916 {
13917 return -1;
13918 }
13919 }
13920 }
13921 case 166:
13922 {
13923 switch (i)
13924 {
13925 case 0:
13926 {
13927 return 39;
13928 }
13929 case 1:
13930 {
13931 return 40;
13932 }
13933 case 2:
13934 case 3:
13935 case 5:
13936 case 6:
13937 case 7:
13938 case 10:
13939 case 11:
13940 case 12:
13941 case 13:
13942 case 14:
13943 case 15:
13944 case 16:
13945 case 17:
13946 case 18:
13947 case 19:
13948 case 20:
13949 case 21:
13950 case 22:
13951 case 23:
13952 case 24:
13953 case 25:
13954 case 26:
13955 case 27:
13956 case 28:
13957 case 29:
13958 case 30:
13959 case 31:
13960 case 32:
13961 case 33:
13962 case 34:
13963 case 35:
13964 case 36:
13965 case 37:
13966 case 38:
13967 case 39:
13968 case 40:
13969 case 41:
13970 case 42:
13971 case 43:
13972 case 44:
13973 case 45:
13974 case 46:
13975 case 47:
13976 case 48:
13977 case 49:
13978 case 50:
13979 case 51:
13980 case 52:
13981 case 53:
13982 case 54:
13983 case 55:
13984 {
13985 return 153;
13986 }
13987 case 4:
13988 {
13989 return 154;
13990 }
13991 case 8:
13992 {
13993 return 155;
13994 }
13995 case 9:
13996 {
13997 return 156;
13998 }
13999 default:
14000 {
14001 return -1;
14002 }
14003 }
14004 }
14005 case 162:
14006 {
14007 switch (i)
14008 {
14009 case 0:
14010 {
14011 return 39;
14012 }
14013 case 1:
14014 {
14015 return 40;
14016 }
14017 case 2:
14018 case 3:
14019 case 5:
14020 case 6:
14021 case 7:
14022 case 10:
14023 case 11:
14024 case 12:
14025 case 13:
14026 case 14:
14027 case 15:
14028 case 16:
14029 case 17:
14030 case 18:
14031 case 19:
14032 case 20:
14033 case 21:
14034 case 22:
14035 case 23:
14036 case 24:
14037 case 25:
14038 case 26:
14039 case 28:
14040 case 29:
14041 case 30:
14042 case 31:
14043 case 32:
14044 case 33:
14045 case 34:
14046 case 35:
14047 case 36:
14048 case 38:
14049 case 39:
14050 case 40:
14051 case 41:
14052 case 42:
14053 case 43:
14054 case 44:
14055 case 45:
14056 case 46:
14057 case 47:
14058 case 48:
14059 case 49:
14060 case 50:
14061 case 51:
14062 case 52:
14063 case 53:
14064 case 54:
14065 case 55:
14066 {
14067 return 153;
14068 }
14069 case 4:
14070 {
14071 return 154;
14072 }
14073 case 8:
14074 {
14075 return 155;
14076 }
14077 case 9:
14078 {
14079 return 156;
14080 }
14081 case 37:
14082 {
14083 return 163;
14084 }
14085 case 27:
14086 {
14087 return 167;
14088 }
14089 default:
14090 {
14091 return -1;
14092 }
14093 }
14094 }
14095 case 167:
14096 {
14097 switch (i)
14098 {
14099 case 0:
14100 {
14101 return 39;
14102 }
14103 case 1:
14104 {
14105 return 40;
14106 }
14107 case 2:
14108 case 3:
14109 case 5:
14110 case 6:
14111 case 7:
14112 case 10:
14113 case 11:
14114 case 12:
14115 case 13:
14116 case 14:
14117 case 15:
14118 case 16:
14119 case 17:
14120 case 18:
14121 case 19:
14122 case 20:
14123 case 21:
14124 case 22:
14125 case 23:
14126 case 24:
14127 case 25:
14128 case 26:
14129 case 27:
14130 case 28:
14131 case 29:
14132 case 30:
14133 case 31:
14134 case 32:
14135 case 33:
14136 case 34:
14137 case 35:
14138 case 36:
14139 case 38:
14140 case 39:
14141 case 40:
14142 case 41:
14143 case 42:
14144 case 43:
14145 case 44:
14146 case 45:
14147 case 46:
14148 case 47:
14149 case 48:
14150 case 49:
14151 case 50:
14152 case 51:
14153 case 52:
14154 case 53:
14155 case 54:
14156 case 55:
14157 {
14158 return 153;
14159 }
14160 case 4:
14161 {
14162 return 154;
14163 }
14164 case 8:
14165 {
14166 return 155;
14167 }
14168 case 9:
14169 {
14170 return 156;
14171 }
14172 case 37:
14173 {
14174 return 164;
14175 }
14176 default:
14177 {
14178 return -1;
14179 }
14180 }
14181 }
14182 case 160:
14183 {
14184 switch (i)
14185 {
14186 case 2:
14187 case 3:
14188 case 5:
14189 case 6:
14190 case 7:
14191 case 8:
14192 case 9:
14193 case 10:
14194 case 11:
14195 case 12:
14196 case 13:
14197 case 14:
14198 case 15:
14199 case 16:
14200 case 17:
14201 case 18:
14202 case 19:
14203 case 20:
14204 case 21:
14205 case 22:
14206 case 23:
14207 case 24:
14208 case 34:
14209 case 35:
14210 case 36:
14211 case 38:
14212 case 39:
14213 case 40:
14214 case 41:
14215 case 42:
14216 case 43:
14217 case 44:
14218 case 45:
14219 case 46:
14220 case 47:
14221 case 48:
14222 case 49:
14223 case 50:
14224 case 51:
14225 case 52:
14226 case 53:
14227 case 54:
14228 case 55:
14229 {
14230 return 7;
14231 }
14232 case 0:
14233 {
14234 return 39;
14235 }
14236 case 1:
14237 {
14238 return 40;
14239 }
14240 case 4:
14241 {
14242 return 41;
14243 }
14244 case 25:
14245 case 26:
14246 case 27:
14247 case 28:
14248 case 29:
14249 case 30:
14250 case 31:
14251 case 32:
14252 case 33:
14253 {
14254 return 168;
14255 }
14256 case 37:
14257 {
14258 return 169;
14259 }
14260 default:
14261 {
14262 return -1;
14263 }
14264 }
14265 }
14266 case 169:
14267 {
14268 switch (i)
14269 {
14270 case 2:
14271 case 3:
14272 case 5:
14273 case 6:
14274 case 7:
14275 case 8:
14276 case 9:
14277 case 10:
14278 case 11:
14279 case 12:
14280 case 13:
14281 case 14:
14282 case 15:
14283 case 16:
14284 case 17:
14285 case 18:
14286 case 19:
14287 case 20:
14288 case 21:
14289 case 22:
14290 case 23:
14291 case 24:
14292 case 34:
14293 case 35:
14294 case 36:
14295 case 37:
14296 case 38:
14297 case 39:
14298 case 40:
14299 case 41:
14300 case 42:
14301 case 43:
14302 case 44:
14303 case 45:
14304 case 46:
14305 case 47:
14306 case 48:
14307 case 49:
14308 case 50:
14309 case 51:
14310 case 52:
14311 case 53:
14312 case 54:
14313 case 55:
14314 {
14315 return 7;
14316 }
14317 case 0:
14318 {
14319 return 39;
14320 }
14321 case 1:
14322 {
14323 return 40;
14324 }
14325 case 4:
14326 {
14327 return 41;
14328 }
14329 case 25:
14330 case 26:
14331 case 27:
14332 case 28:
14333 case 29:
14334 case 30:
14335 case 31:
14336 case 32:
14337 case 33:
14338 {
14339 return 168;
14340 }
14341 default:
14342 {
14343 return -1;
14344 }
14345 }
14346 }
14347 case 168:
14348 {
14349 switch (i)
14350 {
14351 case 0:
14352 {
14353 return 39;
14354 }
14355 case 1:
14356 {
14357 return 40;
14358 }
14359 case 2:
14360 case 3:
14361 case 5:
14362 case 6:
14363 case 7:
14364 case 10:
14365 case 11:
14366 case 12:
14367 case 13:
14368 case 14:
14369 case 15:
14370 case 16:
14371 case 17:
14372 case 18:
14373 case 19:
14374 case 20:
14375 case 21:
14376 case 22:
14377 case 23:
14378 case 24:
14379 case 34:
14380 case 35:
14381 case 36:
14382 case 38:
14383 case 39:
14384 case 40:
14385 case 41:
14386 case 42:
14387 case 43:
14388 case 44:
14389 case 45:
14390 case 46:
14391 case 47:
14392 case 48:
14393 case 49:
14394 case 50:
14395 case 51:
14396 case 52:
14397 case 53:
14398 case 54:
14399 case 55:
14400 {
14401 return 153;
14402 }
14403 case 4:
14404 {
14405 return 154;
14406 }
14407 case 8:
14408 {
14409 return 155;
14410 }
14411 case 9:
14412 {
14413 return 156;
14414 }
14415 case 25:
14416 case 26:
14417 case 27:
14418 case 28:
14419 case 29:
14420 case 30:
14421 case 31:
14422 case 32:
14423 case 33:
14424 {
14425 return 168;
14426 }
14427 case 37:
14428 {
14429 return 170;
14430 }
14431 default:
14432 {
14433 return -1;
14434 }
14435 }
14436 }
14437 case 170:
14438 {
14439 switch (i)
14440 {
14441 case 0:
14442 {
14443 return 39;
14444 }
14445 case 1:
14446 {
14447 return 40;
14448 }
14449 case 2:
14450 case 3:
14451 case 5:
14452 case 6:
14453 case 7:
14454 case 10:
14455 case 11:
14456 case 12:
14457 case 13:
14458 case 14:
14459 case 15:
14460 case 16:
14461 case 17:
14462 case 18:
14463 case 19:
14464 case 20:
14465 case 21:
14466 case 22:
14467 case 23:
14468 case 24:
14469 case 34:
14470 case 35:
14471 case 36:
14472 case 38:
14473 case 39:
14474 case 40:
14475 case 41:
14476 case 42:
14477 case 43:
14478 case 44:
14479 case 45:
14480 case 46:
14481 case 47:
14482 case 48:
14483 case 49:
14484 case 50:
14485 case 51:
14486 case 52:
14487 case 53:
14488 case 54:
14489 case 55:
14490 {
14491 return 153;
14492 }
14493 case 4:
14494 {
14495 return 154;
14496 }
14497 case 8:
14498 {
14499 return 155;
14500 }
14501 case 9:
14502 {
14503 return 156;
14504 }
14505 case 37:
14506 {
14507 return 166;
14508 }
14509 case 25:
14510 case 26:
14511 case 27:
14512 case 28:
14513 case 29:
14514 case 30:
14515 case 31:
14516 case 32:
14517 case 33:
14518 {
14519 return 168;
14520 }
14521 default:
14522 {
14523 return -1;
14524 }
14525 }
14526 }
14527 case 159:
14528 {
14529 switch (i)
14530 {
14531 case 2:
14532 case 3:
14533 case 5:
14534 case 6:
14535 case 7:
14536 case 8:
14537 case 9:
14538 case 10:
14539 case 11:
14540 case 12:
14541 case 13:
14542 case 14:
14543 case 15:
14544 case 16:
14545 case 17:
14546 case 18:
14547 case 19:
14548 case 20:
14549 case 21:
14550 case 22:
14551 case 23:
14552 case 24:
14553 case 34:
14554 case 35:
14555 case 36:
14556 case 37:
14557 case 38:
14558 case 39:
14559 case 40:
14560 case 41:
14561 case 42:
14562 case 43:
14563 case 44:
14564 case 45:
14565 case 46:
14566 case 47:
14567 case 48:
14568 case 49:
14569 case 50:
14570 case 51:
14571 case 52:
14572 case 53:
14573 case 54:
14574 case 55:
14575 {
14576 return 7;
14577 }
14578 case 0:
14579 {
14580 return 39;
14581 }
14582 case 1:
14583 {
14584 return 40;
14585 }
14586 case 4:
14587 {
14588 return 41;
14589 }
14590 case 25:
14591 case 26:
14592 case 27:
14593 case 28:
14594 case 29:
14595 case 30:
14596 case 31:
14597 case 32:
14598 case 33:
14599 {
14600 return 171;
14601 }
14602 default:
14603 {
14604 return -1;
14605 }
14606 }
14607 }
14608 case 171:
14609 {
14610 switch (i)
14611 {
14612 case 2:
14613 case 3:
14614 case 5:
14615 case 6:
14616 case 7:
14617 case 8:
14618 case 9:
14619 case 10:
14620 case 11:
14621 case 12:
14622 case 13:
14623 case 14:
14624 case 15:
14625 case 16:
14626 case 17:
14627 case 18:
14628 case 19:
14629 case 20:
14630 case 21:
14631 case 22:
14632 case 23:
14633 case 24:
14634 case 34:
14635 case 35:
14636 case 36:
14637 case 37:
14638 case 38:
14639 case 39:
14640 case 40:
14641 case 41:
14642 case 42:
14643 case 43:
14644 case 44:
14645 case 45:
14646 case 46:
14647 case 47:
14648 case 48:
14649 case 49:
14650 case 50:
14651 case 51:
14652 case 52:
14653 case 53:
14654 case 54:
14655 case 55:
14656 {
14657 return 7;
14658 }
14659 case 0:
14660 {
14661 return 39;
14662 }
14663 case 1:
14664 {
14665 return 40;
14666 }
14667 case 4:
14668 {
14669 return 41;
14670 }
14671 case 25:
14672 case 26:
14673 case 27:
14674 case 28:
14675 case 29:
14676 case 30:
14677 case 31:
14678 case 32:
14679 case 33:
14680 {
14681 return 172;
14682 }
14683 default:
14684 {
14685 return -1;
14686 }
14687 }
14688 }
14689 case 172:
14690 {
14691 switch (i)
14692 {
14693 case 2:
14694 case 3:
14695 case 5:
14696 case 6:
14697 case 7:
14698 case 8:
14699 case 9:
14700 case 10:
14701 case 11:
14702 case 12:
14703 case 13:
14704 case 14:
14705 case 15:
14706 case 16:
14707 case 17:
14708 case 18:
14709 case 19:
14710 case 20:
14711 case 21:
14712 case 22:
14713 case 23:
14714 case 24:
14715 case 34:
14716 case 35:
14717 case 36:
14718 case 37:
14719 case 38:
14720 case 39:
14721 case 40:
14722 case 41:
14723 case 42:
14724 case 43:
14725 case 44:
14726 case 45:
14727 case 46:
14728 case 47:
14729 case 48:
14730 case 49:
14731 case 50:
14732 case 51:
14733 case 52:
14734 case 53:
14735 case 54:
14736 case 55:
14737 {
14738 return 7;
14739 }
14740 case 0:
14741 {
14742 return 39;
14743 }
14744 case 1:
14745 {
14746 return 40;
14747 }
14748 case 4:
14749 {
14750 return 41;
14751 }
14752 case 25:
14753 case 26:
14754 case 27:
14755 case 28:
14756 case 29:
14757 case 30:
14758 case 31:
14759 case 32:
14760 case 33:
14761 {
14762 return 173;
14763 }
14764 default:
14765 {
14766 return -1;
14767 }
14768 }
14769 }
14770 case 173:
14771 {
14772 switch (i)
14773 {
14774 case 2:
14775 case 3:
14776 case 5:
14777 case 6:
14778 case 7:
14779 case 8:
14780 case 9:
14781 case 10:
14782 case 11:
14783 case 12:
14784 case 13:
14785 case 14:
14786 case 15:
14787 case 16:
14788 case 17:
14789 case 18:
14790 case 19:
14791 case 20:
14792 case 21:
14793 case 22:
14794 case 23:
14795 case 24:
14796 case 34:
14797 case 35:
14798 case 36:
14799 case 37:
14800 case 38:
14801 case 39:
14802 case 40:
14803 case 41:
14804 case 42:
14805 case 43:
14806 case 44:
14807 case 45:
14808 case 46:
14809 case 47:
14810 case 48:
14811 case 49:
14812 case 50:
14813 case 51:
14814 case 52:
14815 case 53:
14816 case 54:
14817 case 55:
14818 {
14819 return 7;
14820 }
14821 case 0:
14822 {
14823 return 39;
14824 }
14825 case 1:
14826 {
14827 return 40;
14828 }
14829 case 4:
14830 {
14831 return 41;
14832 }
14833 case 25:
14834 case 26:
14835 case 27:
14836 case 28:
14837 case 29:
14838 case 30:
14839 case 31:
14840 case 32:
14841 case 33:
14842 {
14843 return 174;
14844 }
14845 default:
14846 {
14847 return -1;
14848 }
14849 }
14850 }
14851 case 174:
14852 {
14853 switch (i)
14854 {
14855 case 2:
14856 case 3:
14857 case 5:
14858 case 6:
14859 case 7:
14860 case 8:
14861 case 9:
14862 case 10:
14863 case 11:
14864 case 12:
14865 case 13:
14866 case 14:
14867 case 15:
14868 case 16:
14869 case 17:
14870 case 18:
14871 case 19:
14872 case 20:
14873 case 21:
14874 case 22:
14875 case 23:
14876 case 24:
14877 case 34:
14878 case 35:
14879 case 36:
14880 case 37:
14881 case 38:
14882 case 39:
14883 case 40:
14884 case 41:
14885 case 42:
14886 case 43:
14887 case 44:
14888 case 45:
14889 case 46:
14890 case 47:
14891 case 48:
14892 case 49:
14893 case 50:
14894 case 51:
14895 case 52:
14896 case 53:
14897 case 54:
14898 case 55:
14899 {
14900 return 7;
14901 }
14902 case 0:
14903 {
14904 return 39;
14905 }
14906 case 1:
14907 {
14908 return 40;
14909 }
14910 case 4:
14911 {
14912 return 41;
14913 }
14914 case 25:
14915 case 26:
14916 case 27:
14917 case 28:
14918 case 29:
14919 case 30:
14920 case 31:
14921 case 32:
14922 case 33:
14923 {
14924 return 175;
14925 }
14926 default:
14927 {
14928 return -1;
14929 }
14930 }
14931 }
14932 case 175:
14933 {
14934 switch (i)
14935 {
14936 case 2:
14937 case 3:
14938 case 5:
14939 case 6:
14940 case 7:
14941 case 8:
14942 case 9:
14943 case 10:
14944 case 11:
14945 case 12:
14946 case 13:
14947 case 14:
14948 case 15:
14949 case 16:
14950 case 17:
14951 case 18:
14952 case 19:
14953 case 20:
14954 case 21:
14955 case 22:
14956 case 23:
14957 case 24:
14958 case 34:
14959 case 35:
14960 case 36:
14961 case 37:
14962 case 38:
14963 case 39:
14964 case 40:
14965 case 41:
14966 case 42:
14967 case 43:
14968 case 44:
14969 case 45:
14970 case 46:
14971 case 47:
14972 case 48:
14973 case 49:
14974 case 50:
14975 case 51:
14976 case 52:
14977 case 53:
14978 case 54:
14979 case 55:
14980 {
14981 return 7;
14982 }
14983 case 0:
14984 {
14985 return 39;
14986 }
14987 case 1:
14988 {
14989 return 40;
14990 }
14991 case 4:
14992 {
14993 return 41;
14994 }
14995 case 25:
14996 case 26:
14997 case 27:
14998 case 28:
14999 case 29:
15000 case 30:
15001 case 31:
15002 case 32:
15003 case 33:
15004 {
15005 return 176;
15006 }
15007 default:
15008 {
15009 return -1;
15010 }
15011 }
15012 }
15013 case 176:
15014 {
15015 switch (i)
15016 {
15017 case 2:
15018 case 3:
15019 case 5:
15020 case 6:
15021 case 7:
15022 case 8:
15023 case 9:
15024 case 10:
15025 case 11:
15026 case 12:
15027 case 13:
15028 case 14:
15029 case 15:
15030 case 16:
15031 case 17:
15032 case 18:
15033 case 19:
15034 case 20:
15035 case 21:
15036 case 22:
15037 case 23:
15038 case 24:
15039 case 34:
15040 case 35:
15041 case 36:
15042 case 37:
15043 case 38:
15044 case 39:
15045 case 40:
15046 case 41:
15047 case 42:
15048 case 43:
15049 case 44:
15050 case 45:
15051 case 46:
15052 case 47:
15053 case 48:
15054 case 49:
15055 case 50:
15056 case 51:
15057 case 52:
15058 case 53:
15059 case 54:
15060 case 55:
15061 {
15062 return 7;
15063 }
15064 case 0:
15065 {
15066 return 39;
15067 }
15068 case 1:
15069 {
15070 return 40;
15071 }
15072 case 4:
15073 {
15074 return 41;
15075 }
15076 case 25:
15077 case 26:
15078 case 27:
15079 case 28:
15080 case 29:
15081 case 30:
15082 case 31:
15083 case 32:
15084 case 33:
15085 {
15086 return 177;
15087 }
15088 default:
15089 {
15090 return -1;
15091 }
15092 }
15093 }
15094 case 177:
15095 {
15096 switch (i)
15097 {
15098 case 2:
15099 case 3:
15100 case 5:
15101 case 6:
15102 case 7:
15103 case 8:
15104 case 9:
15105 case 10:
15106 case 11:
15107 case 12:
15108 case 13:
15109 case 14:
15110 case 15:
15111 case 16:
15112 case 17:
15113 case 18:
15114 case 19:
15115 case 20:
15116 case 21:
15117 case 22:
15118 case 23:
15119 case 24:
15120 case 34:
15121 case 35:
15122 case 36:
15123 case 37:
15124 case 38:
15125 case 39:
15126 case 40:
15127 case 41:
15128 case 42:
15129 case 43:
15130 case 44:
15131 case 45:
15132 case 46:
15133 case 47:
15134 case 48:
15135 case 49:
15136 case 50:
15137 case 51:
15138 case 52:
15139 case 53:
15140 case 54:
15141 case 55:
15142 {
15143 return 7;
15144 }
15145 case 0:
15146 {
15147 return 39;
15148 }
15149 case 1:
15150 {
15151 return 40;
15152 }
15153 case 4:
15154 {
15155 return 41;
15156 }
15157 case 25:
15158 case 26:
15159 case 27:
15160 case 28:
15161 case 29:
15162 case 30:
15163 case 31:
15164 case 32:
15165 case 33:
15166 {
15167 return 178;
15168 }
15169 default:
15170 {
15171 return -1;
15172 }
15173 }
15174 }
15175 case 178:
15176 {
15177 switch (i)
15178 {
15179 case 0:
15180 {
15181 return 39;
15182 }
15183 case 1:
15184 {
15185 return 40;
15186 }
15187 case 2:
15188 case 3:
15189 case 5:
15190 case 6:
15191 case 7:
15192 case 10:
15193 case 11:
15194 case 12:
15195 case 13:
15196 case 14:
15197 case 15:
15198 case 16:
15199 case 17:
15200 case 18:
15201 case 19:
15202 case 20:
15203 case 21:
15204 case 22:
15205 case 23:
15206 case 24:
15207 case 25:
15208 case 26:
15209 case 27:
15210 case 28:
15211 case 29:
15212 case 30:
15213 case 31:
15214 case 32:
15215 case 33:
15216 case 34:
15217 case 35:
15218 case 36:
15219 case 38:
15220 case 39:
15221 case 40:
15222 case 41:
15223 case 42:
15224 case 43:
15225 case 44:
15226 case 45:
15227 case 46:
15228 case 47:
15229 case 48:
15230 case 49:
15231 case 50:
15232 case 51:
15233 case 52:
15234 case 53:
15235 case 54:
15236 case 55:
15237 {
15238 return 153;
15239 }
15240 case 4:
15241 {
15242 return 154;
15243 }
15244 case 8:
15245 {
15246 return 155;
15247 }
15248 case 9:
15249 {
15250 return 156;
15251 }
15252 case 37:
15253 {
15254 return 179;
15255 }
15256 default:
15257 {
15258 return -1;
15259 }
15260 }
15261 }
15262 case 179:
15263 {
15264 switch (i)
15265 {
15266 case 0:
15267 {
15268 return 39;
15269 }
15270 case 1:
15271 {
15272 return 40;
15273 }
15274 case 2:
15275 case 3:
15276 case 5:
15277 case 6:
15278 case 7:
15279 case 10:
15280 case 11:
15281 case 12:
15282 case 13:
15283 case 14:
15284 case 15:
15285 case 16:
15286 case 17:
15287 case 18:
15288 case 19:
15289 case 20:
15290 case 21:
15291 case 22:
15292 case 23:
15293 case 24:
15294 case 25:
15295 case 26:
15296 case 27:
15297 case 28:
15298 case 29:
15299 case 30:
15300 case 31:
15301 case 32:
15302 case 33:
15303 case 34:
15304 case 35:
15305 case 36:
15306 case 37:
15307 case 38:
15308 case 39:
15309 case 40:
15310 case 41:
15311 case 42:
15312 case 43:
15313 case 44:
15314 case 45:
15315 case 46:
15316 case 47:
15317 case 48:
15318 case 49:
15319 case 50:
15320 case 51:
15321 case 52:
15322 case 53:
15323 case 54:
15324 case 55:
15325 {
15326 return 153;
15327 }
15328 case 4:
15329 {
15330 return 154;
15331 }
15332 case 8:
15333 {
15334 return 155;
15335 }
15336 case 9:
15337 {
15338 return 156;
15339 }
15340 default:
15341 {
15342 return -1;
15343 }
15344 }
15345 }
15346 case 158:
15347 {
15348 switch (i)
15349 {
15350 case 2:
15351 case 3:
15352 case 5:
15353 case 6:
15354 case 7:
15355 case 8:
15356 case 9:
15357 case 10:
15358 case 11:
15359 case 12:
15360 case 13:
15361 case 14:
15362 case 15:
15363 case 16:
15364 case 17:
15365 case 18:
15366 case 19:
15367 case 20:
15368 case 21:
15369 case 22:
15370 case 23:
15371 case 24:
15372 case 34:
15373 case 35:
15374 case 36:
15375 case 37:
15376 case 38:
15377 case 39:
15378 case 40:
15379 case 41:
15380 case 42:
15381 case 43:
15382 case 44:
15383 case 45:
15384 case 46:
15385 case 47:
15386 case 48:
15387 case 49:
15388 case 50:
15389 case 51:
15390 case 52:
15391 case 53:
15392 case 54:
15393 case 55:
15394 {
15395 return 7;
15396 }
15397 case 0:
15398 {
15399 return 39;
15400 }
15401 case 1:
15402 {
15403 return 40;
15404 }
15405 case 4:
15406 {
15407 return 41;
15408 }
15409 case 25:
15410 case 26:
15411 case 27:
15412 case 28:
15413 case 29:
15414 case 30:
15415 case 31:
15416 case 32:
15417 case 33:
15418 {
15419 return 180;
15420 }
15421 default:
15422 {
15423 return -1;
15424 }
15425 }
15426 }
15427 case 180:
15428 {
15429 switch (i)
15430 {
15431 case 2:
15432 case 3:
15433 case 5:
15434 case 6:
15435 case 7:
15436 case 8:
15437 case 9:
15438 case 10:
15439 case 11:
15440 case 12:
15441 case 13:
15442 case 14:
15443 case 15:
15444 case 16:
15445 case 17:
15446 case 18:
15447 case 19:
15448 case 20:
15449 case 21:
15450 case 22:
15451 case 23:
15452 case 24:
15453 case 34:
15454 case 35:
15455 case 36:
15456 case 37:
15457 case 38:
15458 case 39:
15459 case 40:
15460 case 41:
15461 case 42:
15462 case 43:
15463 case 44:
15464 case 45:
15465 case 46:
15466 case 47:
15467 case 48:
15468 case 49:
15469 case 50:
15470 case 51:
15471 case 52:
15472 case 53:
15473 case 54:
15474 case 55:
15475 {
15476 return 7;
15477 }
15478 case 0:
15479 {
15480 return 39;
15481 }
15482 case 1:
15483 {
15484 return 40;
15485 }
15486 case 4:
15487 {
15488 return 41;
15489 }
15490 case 25:
15491 case 26:
15492 case 27:
15493 case 28:
15494 case 29:
15495 case 30:
15496 case 31:
15497 case 32:
15498 case 33:
15499 {
15500 return 181;
15501 }
15502 default:
15503 {
15504 return -1;
15505 }
15506 }
15507 }
15508 case 181:
15509 {
15510 switch (i)
15511 {
15512 case 2:
15513 case 3:
15514 case 5:
15515 case 6:
15516 case 7:
15517 case 8:
15518 case 9:
15519 case 10:
15520 case 11:
15521 case 12:
15522 case 13:
15523 case 14:
15524 case 15:
15525 case 16:
15526 case 17:
15527 case 18:
15528 case 19:
15529 case 20:
15530 case 21:
15531 case 22:
15532 case 23:
15533 case 24:
15534 case 34:
15535 case 35:
15536 case 36:
15537 case 37:
15538 case 38:
15539 case 39:
15540 case 40:
15541 case 41:
15542 case 42:
15543 case 43:
15544 case 44:
15545 case 45:
15546 case 46:
15547 case 47:
15548 case 48:
15549 case 49:
15550 case 50:
15551 case 51:
15552 case 52:
15553 case 53:
15554 case 54:
15555 case 55:
15556 {
15557 return 7;
15558 }
15559 case 0:
15560 {
15561 return 39;
15562 }
15563 case 1:
15564 {
15565 return 40;
15566 }
15567 case 4:
15568 {
15569 return 41;
15570 }
15571 case 25:
15572 case 26:
15573 case 27:
15574 case 28:
15575 case 29:
15576 case 30:
15577 case 31:
15578 case 32:
15579 case 33:
15580 {
15581 return 182;
15582 }
15583 default:
15584 {
15585 return -1;
15586 }
15587 }
15588 }
15589 case 182:
15590 {
15591 switch (i)
15592 {
15593 case 2:
15594 case 3:
15595 case 5:
15596 case 6:
15597 case 7:
15598 case 8:
15599 case 9:
15600 case 10:
15601 case 11:
15602 case 12:
15603 case 13:
15604 case 14:
15605 case 15:
15606 case 16:
15607 case 17:
15608 case 18:
15609 case 19:
15610 case 20:
15611 case 21:
15612 case 22:
15613 case 23:
15614 case 24:
15615 case 34:
15616 case 35:
15617 case 36:
15618 case 37:
15619 case 38:
15620 case 39:
15621 case 40:
15622 case 41:
15623 case 42:
15624 case 43:
15625 case 44:
15626 case 45:
15627 case 46:
15628 case 47:
15629 case 48:
15630 case 49:
15631 case 50:
15632 case 51:
15633 case 52:
15634 case 53:
15635 case 54:
15636 case 55:
15637 {
15638 return 7;
15639 }
15640 case 0:
15641 {
15642 return 39;
15643 }
15644 case 1:
15645 {
15646 return 40;
15647 }
15648 case 4:
15649 {
15650 return 41;
15651 }
15652 case 25:
15653 case 26:
15654 case 27:
15655 case 28:
15656 case 29:
15657 case 30:
15658 case 31:
15659 case 32:
15660 case 33:
15661 {
15662 return 183;
15663 }
15664 default:
15665 {
15666 return -1;
15667 }
15668 }
15669 }
15670 case 183:
15671 {
15672 switch (i)
15673 {
15674 case 0:
15675 {
15676 return 39;
15677 }
15678 case 1:
15679 {
15680 return 40;
15681 }
15682 case 2:
15683 case 3:
15684 case 5:
15685 case 6:
15686 case 7:
15687 case 10:
15688 case 11:
15689 case 12:
15690 case 13:
15691 case 14:
15692 case 15:
15693 case 16:
15694 case 17:
15695 case 18:
15696 case 19:
15697 case 20:
15698 case 21:
15699 case 22:
15700 case 23:
15701 case 24:
15702 case 25:
15703 case 26:
15704 case 27:
15705 case 28:
15706 case 29:
15707 case 30:
15708 case 31:
15709 case 32:
15710 case 33:
15711 case 34:
15712 case 35:
15713 case 36:
15714 case 38:
15715 case 39:
15716 case 40:
15717 case 41:
15718 case 42:
15719 case 43:
15720 case 44:
15721 case 45:
15722 case 46:
15723 case 47:
15724 case 48:
15725 case 49:
15726 case 50:
15727 case 51:
15728 case 52:
15729 case 53:
15730 case 54:
15731 case 55:
15732 {
15733 return 153;
15734 }
15735 case 4:
15736 {
15737 return 154;
15738 }
15739 case 8:
15740 {
15741 return 155;
15742 }
15743 case 9:
15744 {
15745 return 156;
15746 }
15747 case 37:
15748 {
15749 return 179;
15750 }
15751 default:
15752 {
15753 return -1;
15754 }
15755 }
15756 }
15757 case 157:
15758 {
15759 switch (i)
15760 {
15761 case 0:
15762 {
15763 return 39;
15764 }
15765 case 1:
15766 {
15767 return 40;
15768 }
15769 case 2:
15770 case 3:
15771 case 5:
15772 case 6:
15773 case 7:
15774 case 10:
15775 case 11:
15776 case 12:
15777 case 13:
15778 case 14:
15779 case 15:
15780 case 16:
15781 case 17:
15782 case 18:
15783 case 19:
15784 case 20:
15785 case 21:
15786 case 22:
15787 case 23:
15788 case 24:
15789 case 25:
15790 case 26:
15791 case 27:
15792 case 28:
15793 case 29:
15794 case 30:
15795 case 31:
15796 case 32:
15797 case 33:
15798 case 34:
15799 case 35:
15800 case 36:
15801 case 38:
15802 case 39:
15803 case 40:
15804 case 41:
15805 case 42:
15806 case 43:
15807 case 44:
15808 case 45:
15809 case 46:
15810 case 47:
15811 case 48:
15812 case 49:
15813 case 50:
15814 case 51:
15815 case 52:
15816 case 53:
15817 case 54:
15818 case 55:
15819 {
15820 return 153;
15821 }
15822 case 4:
15823 {
15824 return 154;
15825 }
15826 case 8:
15827 {
15828 return 155;
15829 }
15830 case 9:
15831 {
15832 return 156;
15833 }
15834 case 37:
15835 {
15836 return 165;
15837 }
15838 default:
15839 {
15840 return -1;
15841 }
15842 }
15843 }
15844 case 154:
15845 {
15846 switch (i)
15847 {
15848 case 0:
15849 {
15850 return 39;
15851 }
15852 case 1:
15853 {
15854 return 40;
15855 }
15856 case 4:
15857 {
15858 return 154;
15859 }
15860 case 2:
15861 case 5:
15862 case 6:
15863 case 7:
15864 case 10:
15865 case 11:
15866 case 12:
15867 case 13:
15868 case 14:
15869 case 15:
15870 case 16:
15871 case 17:
15872 case 18:
15873 case 19:
15874 case 20:
15875 case 21:
15876 case 22:
15877 case 23:
15878 case 24:
15879 case 25:
15880 case 26:
15881 case 27:
15882 case 28:
15883 case 29:
15884 case 30:
15885 case 31:
15886 case 32:
15887 case 33:
15888 case 34:
15889 case 35:
15890 case 36:
15891 case 37:
15892 case 38:
15893 case 39:
15894 case 40:
15895 case 41:
15896 case 42:
15897 case 43:
15898 case 44:
15899 case 45:
15900 case 46:
15901 case 47:
15902 case 48:
15903 case 49:
15904 case 50:
15905 case 51:
15906 case 52:
15907 case 53:
15908 case 54:
15909 case 55:
15910 {
15911 return 184;
15912 }
15913 case 3:
15914 {
15915 return 185;
15916 }
15917 case 8:
15918 {
15919 return 186;
15920 }
15921 case 9:
15922 {
15923 return 187;
15924 }
15925 default:
15926 {
15927 return -1;
15928 }
15929 }
15930 }
15931 case 187:
15932 {
15933 Lexeme prevMatch = token.match;
15934 token.match = lexeme;
15935 int tokenId = GetTokenId(6);
15936 if (tokenId == CONTINUE_TOKEN)
15937 {
15938 token.id = tokenId;
15939 return -1;
15940 }
15941 else if (tokenId != INVALID_TOKEN)
15942 {
15943 token.id = tokenId;
15944 }
15945 else
15946 {
15947 token.match = prevMatch;
15948 }
15949 switch (i)
15950 {
15951 case 2:
15952 case 3:
15953 case 5:
15954 case 6:
15955 case 7:
15956 case 8:
15957 case 9:
15958 case 10:
15959 case 11:
15960 case 12:
15961 case 13:
15962 case 14:
15963 case 15:
15964 case 16:
15965 case 17:
15966 case 18:
15967 case 19:
15968 case 20:
15969 case 21:
15970 case 22:
15971 case 23:
15972 case 24:
15973 case 25:
15974 case 26:
15975 case 27:
15976 case 28:
15977 case 29:
15978 case 30:
15979 case 31:
15980 case 32:
15981 case 33:
15982 case 34:
15983 case 35:
15984 case 36:
15985 case 37:
15986 case 38:
15987 case 39:
15988 case 40:
15989 case 41:
15990 case 42:
15991 case 43:
15992 case 44:
15993 case 45:
15994 case 46:
15995 case 47:
15996 case 48:
15997 case 49:
15998 case 50:
15999 case 51:
16000 case 52:
16001 case 53:
16002 case 54:
16003 case 55:
16004 {
16005 return 7;
16006 }
16007 case 0:
16008 {
16009 return 39;
16010 }
16011 case 1:
16012 {
16013 return 40;
16014 }
16015 case 4:
16016 {
16017 return 41;
16018 }
16019 default:
16020 {
16021 return -1;
16022 }
16023 }
16024 }
16025 case 186:
16026 {
16027 switch (i)
16028 {
16029 case 3:
16030 case 5:
16031 case 6:
16032 case 7:
16033 case 11:
16034 case 12:
16035 case 13:
16036 case 14:
16037 case 17:
16038 case 23:
16039 case 24:
16040 case 25:
16041 case 26:
16042 case 28:
16043 case 32:
16044 case 33:
16045 case 34:
16046 case 35:
16047 case 36:
16048 case 37:
16049 case 38:
16050 case 39:
16051 case 40:
16052 case 41:
16053 case 42:
16054 case 43:
16055 case 44:
16056 case 45:
16057 case 46:
16058 case 47:
16059 case 48:
16060 case 49:
16061 case 50:
16062 case 51:
16063 case 52:
16064 case 53:
16065 case 54:
16066 case 55:
16067 {
16068 return 7;
16069 }
16070 case 0:
16071 {
16072 return 39;
16073 }
16074 case 1:
16075 {
16076 return 40;
16077 }
16078 case 4:
16079 {
16080 return 41;
16081 }
16082 case 2:
16083 case 8:
16084 case 9:
16085 case 10:
16086 case 19:
16087 case 20:
16088 case 21:
16089 case 22:
16090 case 29:
16091 case 30:
16092 case 31:
16093 {
16094 return 157;
16095 }
16096 case 15:
16097 {
16098 return 158;
16099 }
16100 case 16:
16101 {
16102 return 159;
16103 }
16104 case 18:
16105 {
16106 return 160;
16107 }
16108 case 27:
16109 {
16110 return 161;
16111 }
16112 default:
16113 {
16114 return -1;
16115 }
16116 }
16117 }
16118 case 185:
16119 {
16120 Lexeme prevMatch = token.match;
16121 token.match = lexeme;
16122 int tokenId = GetTokenId(4);
16123 if (tokenId == CONTINUE_TOKEN)
16124 {
16125 token.id = tokenId;
16126 return -1;
16127 }
16128 else if (tokenId != INVALID_TOKEN)
16129 {
16130 token.id = tokenId;
16131 }
16132 else
16133 {
16134 token.match = prevMatch;
16135 }
16136 switch (i)
16137 {
16138 case 0:
16139 {
16140 return 39;
16141 }
16142 case 1:
16143 {
16144 return 40;
16145 }
16146 case 2:
16147 case 3:
16148 case 5:
16149 case 6:
16150 case 7:
16151 case 10:
16152 case 11:
16153 case 12:
16154 case 13:
16155 case 14:
16156 case 15:
16157 case 16:
16158 case 17:
16159 case 18:
16160 case 19:
16161 case 20:
16162 case 21:
16163 case 22:
16164 case 23:
16165 case 24:
16166 case 25:
16167 case 26:
16168 case 27:
16169 case 28:
16170 case 29:
16171 case 30:
16172 case 31:
16173 case 32:
16174 case 33:
16175 case 34:
16176 case 35:
16177 case 36:
16178 case 38:
16179 case 39:
16180 case 40:
16181 case 41:
16182 case 42:
16183 case 43:
16184 case 44:
16185 case 45:
16186 case 46:
16187 case 47:
16188 case 48:
16189 case 49:
16190 case 50:
16191 case 51:
16192 case 52:
16193 case 53:
16194 case 54:
16195 case 55:
16196 {
16197 return 153;
16198 }
16199 case 4:
16200 {
16201 return 154;
16202 }
16203 case 8:
16204 {
16205 return 155;
16206 }
16207 case 9:
16208 {
16209 return 156;
16210 }
16211 case 37:
16212 {
16213 return 188;
16214 }
16215 default:
16216 {
16217 return -1;
16218 }
16219 }
16220 }
16221 case 188:
16222 {
16223 Lexeme prevMatch = token.match;
16224 token.match = lexeme;
16225 int tokenId = GetTokenId(4);
16226 if (tokenId == CONTINUE_TOKEN)
16227 {
16228 token.id = tokenId;
16229 return -1;
16230 }
16231 else if (tokenId != INVALID_TOKEN)
16232 {
16233 token.id = tokenId;
16234 }
16235 else
16236 {
16237 token.match = prevMatch;
16238 }
16239 switch (i)
16240 {
16241 case 0:
16242 {
16243 return 39;
16244 }
16245 case 1:
16246 {
16247 return 40;
16248 }
16249 case 2:
16250 case 3:
16251 case 5:
16252 case 6:
16253 case 7:
16254 case 10:
16255 case 11:
16256 case 12:
16257 case 13:
16258 case 14:
16259 case 15:
16260 case 16:
16261 case 17:
16262 case 18:
16263 case 19:
16264 case 20:
16265 case 21:
16266 case 22:
16267 case 23:
16268 case 24:
16269 case 25:
16270 case 26:
16271 case 27:
16272 case 28:
16273 case 29:
16274 case 30:
16275 case 31:
16276 case 32:
16277 case 33:
16278 case 34:
16279 case 35:
16280 case 36:
16281 case 37:
16282 case 38:
16283 case 39:
16284 case 40:
16285 case 41:
16286 case 42:
16287 case 43:
16288 case 44:
16289 case 45:
16290 case 46:
16291 case 47:
16292 case 48:
16293 case 49:
16294 case 50:
16295 case 51:
16296 case 52:
16297 case 53:
16298 case 54:
16299 case 55:
16300 {
16301 return 153;
16302 }
16303 case 4:
16304 {
16305 return 154;
16306 }
16307 case 8:
16308 {
16309 return 155;
16310 }
16311 case 9:
16312 {
16313 return 156;
16314 }
16315 default:
16316 {
16317 return -1;
16318 }
16319 }
16320 }
16321 case 184:
16322 {
16323 switch (i)
16324 {
16325 case 0:
16326 {
16327 return 39;
16328 }
16329 case 1:
16330 {
16331 return 40;
16332 }
16333 case 2:
16334 case 3:
16335 case 5:
16336 case 6:
16337 case 7:
16338 case 10:
16339 case 11:
16340 case 12:
16341 case 13:
16342 case 14:
16343 case 15:
16344 case 16:
16345 case 17:
16346 case 18:
16347 case 19:
16348 case 20:
16349 case 21:
16350 case 22:
16351 case 23:
16352 case 24:
16353 case 25:
16354 case 26:
16355 case 27:
16356 case 28:
16357 case 29:
16358 case 30:
16359 case 31:
16360 case 32:
16361 case 33:
16362 case 34:
16363 case 35:
16364 case 36:
16365 case 37:
16366 case 38:
16367 case 39:
16368 case 40:
16369 case 41:
16370 case 42:
16371 case 43:
16372 case 44:
16373 case 45:
16374 case 46:
16375 case 47:
16376 case 48:
16377 case 49:
16378 case 50:
16379 case 51:
16380 case 52:
16381 case 53:
16382 case 54:
16383 case 55:
16384 {
16385 return 153;
16386 }
16387 case 4:
16388 {
16389 return 154;
16390 }
16391 case 8:
16392 {
16393 return 155;
16394 }
16395 case 9:
16396 {
16397 return 156;
16398 }
16399 default:
16400 {
16401 return -1;
16402 }
16403 }
16404 }
16405 case 153:
16406 {
16407 switch (i)
16408 {
16409 case 0:
16410 {
16411 return 39;
16412 }
16413 case 1:
16414 {
16415 return 40;
16416 }
16417 case 2:
16418 case 3:
16419 case 5:
16420 case 6:
16421 case 7:
16422 case 10:
16423 case 11:
16424 case 12:
16425 case 13:
16426 case 14:
16427 case 15:
16428 case 16:
16429 case 17:
16430 case 18:
16431 case 19:
16432 case 20:
16433 case 21:
16434 case 22:
16435 case 23:
16436 case 24:
16437 case 25:
16438 case 26:
16439 case 27:
16440 case 28:
16441 case 29:
16442 case 30:
16443 case 31:
16444 case 32:
16445 case 33:
16446 case 34:
16447 case 35:
16448 case 36:
16449 case 37:
16450 case 38:
16451 case 39:
16452 case 40:
16453 case 41:
16454 case 42:
16455 case 43:
16456 case 44:
16457 case 45:
16458 case 46:
16459 case 47:
16460 case 48:
16461 case 49:
16462 case 50:
16463 case 51:
16464 case 52:
16465 case 53:
16466 case 54:
16467 case 55:
16468 {
16469 return 153;
16470 }
16471 case 4:
16472 {
16473 return 154;
16474 }
16475 case 8:
16476 {
16477 return 155;
16478 }
16479 case 9:
16480 {
16481 return 156;
16482 }
16483 default:
16484 {
16485 return -1;
16486 }
16487 }
16488 }
16489 case 7:
16490 {
16491 switch (i)
16492 {
16493 case 2:
16494 case 3:
16495 case 5:
16496 case 6:
16497 case 7:
16498 case 8:
16499 case 9:
16500 case 10:
16501 case 11:
16502 case 12:
16503 case 13:
16504 case 14:
16505 case 15:
16506 case 16:
16507 case 17:
16508 case 18:
16509 case 19:
16510 case 20:
16511 case 21:
16512 case 22:
16513 case 23:
16514 case 24:
16515 case 25:
16516 case 26:
16517 case 27:
16518 case 28:
16519 case 29:
16520 case 30:
16521 case 31:
16522 case 32:
16523 case 33:
16524 case 34:
16525 case 35:
16526 case 36:
16527 case 37:
16528 case 38:
16529 case 39:
16530 case 40:
16531 case 41:
16532 case 42:
16533 case 43:
16534 case 44:
16535 case 45:
16536 case 46:
16537 case 47:
16538 case 48:
16539 case 49:
16540 case 50:
16541 case 51:
16542 case 52:
16543 case 53:
16544 case 54:
16545 case 55:
16546 {
16547 return 7;
16548 }
16549 case 0:
16550 {
16551 return 39;
16552 }
16553 case 1:
16554 {
16555 return 40;
16556 }
16557 case 4:
16558 {
16559 return 41;
16560 }
16561 default:
16562 {
16563 return -1;
16564 }
16565 }
16566 }
16567 case 6:
16568 {
16569 Lexeme prevMatch = token.match;
16570 token.match = lexeme;
16571 int tokenId = GetTokenId(5);
16572 if (tokenId == CONTINUE_TOKEN)
16573 {
16574 token.id = tokenId;
16575 return -1;
16576 }
16577 else if (tokenId != INVALID_TOKEN)
16578 {
16579 token.id = tokenId;
16580 }
16581 else
16582 {
16583 token.match = prevMatch;
16584 }
16585 switch (i)
16586 {
16587 case 2:
16588 case 3:
16589 case 7:
16590 case 8:
16591 case 9:
16592 case 10:
16593 case 11:
16594 case 12:
16595 case 13:
16596 case 34:
16597 case 35:
16598 case 36:
16599 case 38:
16600 case 39:
16601 case 40:
16602 case 41:
16603 case 42:
16604 case 43:
16605 case 44:
16606 case 45:
16607 case 46:
16608 case 47:
16609 case 48:
16610 case 49:
16611 case 50:
16612 case 51:
16613 case 52:
16614 case 53:
16615 case 54:
16616 case 55:
16617 {
16618 return 7;
16619 }
16620 case 0:
16621 {
16622 return 39;
16623 }
16624 case 1:
16625 {
16626 return 40;
16627 }
16628 case 4:
16629 {
16630 return 41;
16631 }
16632 case 5:
16633 case 6:
16634 case 14:
16635 case 15:
16636 case 16:
16637 case 17:
16638 case 18:
16639 case 19:
16640 case 20:
16641 case 21:
16642 case 22:
16643 case 23:
16644 case 24:
16645 case 25:
16646 case 26:
16647 case 27:
16648 case 28:
16649 case 29:
16650 case 30:
16651 case 31:
16652 case 32:
16653 case 33:
16654 {
16655 return 137;
16656 }
16657 case 37:
16658 {
16659 return 138;
16660 }
16661 default:
16662 {
16663 return -1;
16664 }
16665 }
16666 }
16667 case 5:
16668 {
16669 Lexeme prevMatch = token.match;
16670 token.match = lexeme;
16671 int tokenId = GetTokenId(41);
16672 if (tokenId == CONTINUE_TOKEN)
16673 {
16674 token.id = tokenId;
16675 return -1;
16676 }
16677 else if (tokenId != INVALID_TOKEN)
16678 {
16679 token.id = tokenId;
16680 }
16681 else
16682 {
16683 token.match = prevMatch;
16684 }
16685 switch (i)
16686 {
16687 case 0:
16688 {
16689 return 39;
16690 }
16691 case 1:
16692 {
16693 return 40;
16694 }
16695 case 4:
16696 {
16697 return 41;
16698 }
16699 case 2:
16700 case 5:
16701 case 6:
16702 case 7:
16703 case 8:
16704 case 9:
16705 case 10:
16706 case 11:
16707 case 12:
16708 case 13:
16709 case 14:
16710 case 15:
16711 case 16:
16712 case 17:
16713 case 18:
16714 case 19:
16715 case 20:
16716 case 21:
16717 case 22:
16718 case 23:
16719 case 24:
16720 case 25:
16721 case 26:
16722 case 27:
16723 case 28:
16724 case 29:
16725 case 30:
16726 case 31:
16727 case 32:
16728 case 33:
16729 case 34:
16730 case 35:
16731 case 36:
16732 case 37:
16733 case 38:
16734 case 39:
16735 case 41:
16736 case 42:
16737 case 43:
16738 case 44:
16739 case 45:
16740 case 46:
16741 case 47:
16742 case 48:
16743 case 49:
16744 case 50:
16745 case 51:
16746 case 52:
16747 case 53:
16748 case 54:
16749 case 55:
16750 {
16751 return 42;
16752 }
16753 case 3:
16754 {
16755 return 43;
16756 }
16757 case 40:
16758 {
16759 return 189;
16760 }
16761 default:
16762 {
16763 return -1;
16764 }
16765 }
16766 }
16767 case 189:
16768 {
16769 Lexeme prevMatch = token.match;
16770 token.match = lexeme;
16771 int tokenId = GetTokenId(13);
16772 if (tokenId == CONTINUE_TOKEN)
16773 {
16774 token.id = tokenId;
16775 return -1;
16776 }
16777 else if (tokenId != INVALID_TOKEN)
16778 {
16779 token.id = tokenId;
16780 }
16781 else
16782 {
16783 token.match = prevMatch;
16784 }
16785 switch (i)
16786 {
16787 case 2:
16788 case 3:
16789 case 5:
16790 case 6:
16791 case 7:
16792 case 8:
16793 case 9:
16794 case 10:
16795 case 11:
16796 case 12:
16797 case 13:
16798 case 14:
16799 case 15:
16800 case 16:
16801 case 17:
16802 case 18:
16803 case 19:
16804 case 20:
16805 case 21:
16806 case 22:
16807 case 23:
16808 case 24:
16809 case 25:
16810 case 26:
16811 case 27:
16812 case 28:
16813 case 29:
16814 case 30:
16815 case 31:
16816 case 32:
16817 case 33:
16818 case 34:
16819 case 35:
16820 case 36:
16821 case 37:
16822 case 38:
16823 case 39:
16824 case 40:
16825 case 41:
16826 case 42:
16827 case 43:
16828 case 44:
16829 case 45:
16830 case 46:
16831 case 47:
16832 case 48:
16833 case 49:
16834 case 50:
16835 case 51:
16836 case 52:
16837 case 53:
16838 case 54:
16839 case 55:
16840 {
16841 return 7;
16842 }
16843 case 0:
16844 {
16845 return 39;
16846 }
16847 case 1:
16848 {
16849 return 40;
16850 }
16851 case 4:
16852 {
16853 return 41;
16854 }
16855 default:
16856 {
16857 return -1;
16858 }
16859 }
16860 }
16861 case 4:
16862 {
16863 Lexeme prevMatch = token.match;
16864 token.match = lexeme;
16865 int tokenId = GetTokenId(42);
16866 if (tokenId == CONTINUE_TOKEN)
16867 {
16868 token.id = tokenId;
16869 return -1;
16870 }
16871 else if (tokenId != INVALID_TOKEN)
16872 {
16873 token.id = tokenId;
16874 }
16875 else
16876 {
16877 token.match = prevMatch;
16878 }
16879 switch (i)
16880 {
16881 case 2:
16882 case 5:
16883 case 6:
16884 case 7:
16885 case 8:
16886 case 9:
16887 case 10:
16888 case 11:
16889 case 12:
16890 case 13:
16891 case 14:
16892 case 15:
16893 case 16:
16894 case 17:
16895 case 18:
16896 case 19:
16897 case 20:
16898 case 21:
16899 case 22:
16900 case 23:
16901 case 24:
16902 case 25:
16903 case 26:
16904 case 27:
16905 case 28:
16906 case 29:
16907 case 30:
16908 case 31:
16909 case 32:
16910 case 33:
16911 case 34:
16912 case 35:
16913 case 36:
16914 case 37:
16915 case 38:
16916 case 39:
16917 case 41:
16918 case 42:
16919 case 43:
16920 case 44:
16921 case 45:
16922 case 46:
16923 case 47:
16924 case 48:
16925 case 49:
16926 case 50:
16927 case 51:
16928 case 52:
16929 case 53:
16930 case 54:
16931 case 55:
16932 {
16933 return 7;
16934 }
16935 case 0:
16936 {
16937 return 39;
16938 }
16939 case 1:
16940 {
16941 return 40;
16942 }
16943 case 3:
16944 {
16945 return 190;
16946 }
16947 case 4:
16948 {
16949 return 191;
16950 }
16951 case 40:
16952 {
16953 return 192;
16954 }
16955 default:
16956 {
16957 return -1;
16958 }
16959 }
16960 }
16961 case 192:
16962 {
16963 Lexeme prevMatch = token.match;
16964 token.match = lexeme;
16965 int tokenId = GetTokenId(14);
16966 if (tokenId == CONTINUE_TOKEN)
16967 {
16968 token.id = tokenId;
16969 return -1;
16970 }
16971 else if (tokenId != INVALID_TOKEN)
16972 {
16973 token.id = tokenId;
16974 }
16975 else
16976 {
16977 token.match = prevMatch;
16978 }
16979 switch (i)
16980 {
16981 case 2:
16982 case 3:
16983 case 5:
16984 case 6:
16985 case 7:
16986 case 8:
16987 case 9:
16988 case 10:
16989 case 11:
16990 case 12:
16991 case 13:
16992 case 14:
16993 case 15:
16994 case 16:
16995 case 17:
16996 case 18:
16997 case 19:
16998 case 20:
16999 case 21:
17000 case 22:
17001 case 23:
17002 case 24:
17003 case 25:
17004 case 26:
17005 case 27:
17006 case 28:
17007 case 29:
17008 case 30:
17009 case 31:
17010 case 32:
17011 case 33:
17012 case 34:
17013 case 35:
17014 case 36:
17015 case 37:
17016 case 38:
17017 case 39:
17018 case 40:
17019 case 41:
17020 case 42:
17021 case 43:
17022 case 44:
17023 case 45:
17024 case 46:
17025 case 47:
17026 case 48:
17027 case 49:
17028 case 50:
17029 case 51:
17030 case 52:
17031 case 53:
17032 case 54:
17033 case 55:
17034 {
17035 return 7;
17036 }
17037 case 0:
17038 {
17039 return 39;
17040 }
17041 case 1:
17042 {
17043 return 40;
17044 }
17045 case 4:
17046 {
17047 return 41;
17048 }
17049 default:
17050 {
17051 return -1;
17052 }
17053 }
17054 }
17055 case 191:
17056 {
17057 switch (i)
17058 {
17059 case 0:
17060 {
17061 return 193;
17062 }
17063 case 1:
17064 {
17065 return 194;
17066 }
17067 case 2:
17068 case 5:
17069 case 6:
17070 case 7:
17071 case 8:
17072 case 9:
17073 case 10:
17074 case 11:
17075 case 12:
17076 case 13:
17077 case 14:
17078 case 15:
17079 case 16:
17080 case 17:
17081 case 18:
17082 case 19:
17083 case 20:
17084 case 21:
17085 case 22:
17086 case 23:
17087 case 24:
17088 case 25:
17089 case 26:
17090 case 27:
17091 case 28:
17092 case 29:
17093 case 30:
17094 case 31:
17095 case 32:
17096 case 33:
17097 case 34:
17098 case 35:
17099 case 36:
17100 case 37:
17101 case 38:
17102 case 39:
17103 case 40:
17104 case 41:
17105 case 42:
17106 case 43:
17107 case 44:
17108 case 45:
17109 case 46:
17110 case 47:
17111 case 48:
17112 case 49:
17113 case 50:
17114 case 51:
17115 case 52:
17116 case 53:
17117 case 54:
17118 case 55:
17119 {
17120 return 195;
17121 }
17122 case 3:
17123 {
17124 return 196;
17125 }
17126 case 4:
17127 {
17128 return 197;
17129 }
17130 default:
17131 {
17132 return -1;
17133 }
17134 }
17135 }
17136 case 197:
17137 {
17138 switch (i)
17139 {
17140 case 0:
17141 {
17142 return 193;
17143 }
17144 case 1:
17145 {
17146 return 194;
17147 }
17148 case 4:
17149 {
17150 return 197;
17151 }
17152 case 2:
17153 case 5:
17154 case 6:
17155 case 7:
17156 case 8:
17157 case 9:
17158 case 10:
17159 case 11:
17160 case 12:
17161 case 13:
17162 case 14:
17163 case 15:
17164 case 16:
17165 case 17:
17166 case 18:
17167 case 19:
17168 case 20:
17169 case 21:
17170 case 22:
17171 case 23:
17172 case 24:
17173 case 25:
17174 case 26:
17175 case 27:
17176 case 28:
17177 case 29:
17178 case 30:
17179 case 31:
17180 case 32:
17181 case 33:
17182 case 34:
17183 case 35:
17184 case 36:
17185 case 37:
17186 case 38:
17187 case 39:
17188 case 40:
17189 case 41:
17190 case 42:
17191 case 43:
17192 case 44:
17193 case 45:
17194 case 46:
17195 case 47:
17196 case 48:
17197 case 49:
17198 case 50:
17199 case 51:
17200 case 52:
17201 case 53:
17202 case 54:
17203 case 55:
17204 {
17205 return 198;
17206 }
17207 case 3:
17208 {
17209 return 199;
17210 }
17211 default:
17212 {
17213 return -1;
17214 }
17215 }
17216 }
17217 case 199:
17218 {
17219 Lexeme prevMatch = token.match;
17220 token.match = lexeme;
17221 int tokenId = GetTokenId(3);
17222 if (tokenId == CONTINUE_TOKEN)
17223 {
17224 token.id = tokenId;
17225 return -1;
17226 }
17227 else if (tokenId != INVALID_TOKEN)
17228 {
17229 token.id = tokenId;
17230 }
17231 else
17232 {
17233 token.match = prevMatch;
17234 }
17235 switch (i)
17236 {
17237 case 0:
17238 {
17239 return 193;
17240 }
17241 case 1:
17242 {
17243 return 194;
17244 }
17245 case 4:
17246 {
17247 return 197;
17248 }
17249 case 2:
17250 case 3:
17251 case 5:
17252 case 6:
17253 case 7:
17254 case 8:
17255 case 9:
17256 case 10:
17257 case 11:
17258 case 12:
17259 case 13:
17260 case 14:
17261 case 15:
17262 case 16:
17263 case 17:
17264 case 18:
17265 case 19:
17266 case 20:
17267 case 21:
17268 case 22:
17269 case 23:
17270 case 24:
17271 case 25:
17272 case 26:
17273 case 27:
17274 case 28:
17275 case 29:
17276 case 30:
17277 case 31:
17278 case 32:
17279 case 33:
17280 case 34:
17281 case 35:
17282 case 36:
17283 case 38:
17284 case 39:
17285 case 40:
17286 case 41:
17287 case 42:
17288 case 43:
17289 case 44:
17290 case 45:
17291 case 46:
17292 case 47:
17293 case 48:
17294 case 49:
17295 case 50:
17296 case 51:
17297 case 52:
17298 case 53:
17299 case 54:
17300 case 55:
17301 {
17302 return 200;
17303 }
17304 case 37:
17305 {
17306 return 201;
17307 }
17308 default:
17309 {
17310 return -1;
17311 }
17312 }
17313 }
17314 case 201:
17315 {
17316 Lexeme prevMatch = token.match;
17317 token.match = lexeme;
17318 int tokenId = GetTokenId(3);
17319 if (tokenId == CONTINUE_TOKEN)
17320 {
17321 token.id = tokenId;
17322 return -1;
17323 }
17324 else if (tokenId != INVALID_TOKEN)
17325 {
17326 token.id = tokenId;
17327 }
17328 else
17329 {
17330 token.match = prevMatch;
17331 }
17332 switch (i)
17333 {
17334 case 0:
17335 {
17336 return 193;
17337 }
17338 case 1:
17339 {
17340 return 194;
17341 }
17342 case 4:
17343 {
17344 return 197;
17345 }
17346 case 2:
17347 case 3:
17348 case 5:
17349 case 6:
17350 case 7:
17351 case 8:
17352 case 9:
17353 case 10:
17354 case 11:
17355 case 12:
17356 case 13:
17357 case 14:
17358 case 15:
17359 case 16:
17360 case 17:
17361 case 18:
17362 case 19:
17363 case 20:
17364 case 21:
17365 case 22:
17366 case 23:
17367 case 24:
17368 case 25:
17369 case 26:
17370 case 27:
17371 case 28:
17372 case 29:
17373 case 30:
17374 case 31:
17375 case 32:
17376 case 33:
17377 case 34:
17378 case 35:
17379 case 36:
17380 case 37:
17381 case 38:
17382 case 39:
17383 case 40:
17384 case 41:
17385 case 42:
17386 case 43:
17387 case 44:
17388 case 45:
17389 case 46:
17390 case 47:
17391 case 48:
17392 case 49:
17393 case 50:
17394 case 51:
17395 case 52:
17396 case 53:
17397 case 54:
17398 case 55:
17399 {
17400 return 200;
17401 }
17402 default:
17403 {
17404 return -1;
17405 }
17406 }
17407 }
17408 case 200:
17409 {
17410 switch (i)
17411 {
17412 case 0:
17413 {
17414 return 193;
17415 }
17416 case 1:
17417 {
17418 return 194;
17419 }
17420 case 4:
17421 {
17422 return 197;
17423 }
17424 case 2:
17425 case 3:
17426 case 5:
17427 case 6:
17428 case 7:
17429 case 8:
17430 case 9:
17431 case 10:
17432 case 11:
17433 case 12:
17434 case 13:
17435 case 14:
17436 case 15:
17437 case 16:
17438 case 17:
17439 case 18:
17440 case 19:
17441 case 20:
17442 case 21:
17443 case 22:
17444 case 23:
17445 case 24:
17446 case 25:
17447 case 26:
17448 case 27:
17449 case 28:
17450 case 29:
17451 case 30:
17452 case 31:
17453 case 32:
17454 case 33:
17455 case 34:
17456 case 35:
17457 case 36:
17458 case 37:
17459 case 38:
17460 case 39:
17461 case 40:
17462 case 41:
17463 case 42:
17464 case 43:
17465 case 44:
17466 case 45:
17467 case 46:
17468 case 47:
17469 case 48:
17470 case 49:
17471 case 50:
17472 case 51:
17473 case 52:
17474 case 53:
17475 case 54:
17476 case 55:
17477 {
17478 return 200;
17479 }
17480 default:
17481 {
17482 return -1;
17483 }
17484 }
17485 }
17486 case 198:
17487 {
17488 switch (i)
17489 {
17490 case 0:
17491 {
17492 return 193;
17493 }
17494 case 1:
17495 {
17496 return 194;
17497 }
17498 case 4:
17499 {
17500 return 197;
17501 }
17502 case 2:
17503 case 3:
17504 case 5:
17505 case 6:
17506 case 7:
17507 case 8:
17508 case 9:
17509 case 10:
17510 case 11:
17511 case 12:
17512 case 13:
17513 case 14:
17514 case 15:
17515 case 16:
17516 case 17:
17517 case 18:
17518 case 19:
17519 case 20:
17520 case 21:
17521 case 22:
17522 case 23:
17523 case 24:
17524 case 25:
17525 case 26:
17526 case 27:
17527 case 28:
17528 case 29:
17529 case 30:
17530 case 31:
17531 case 32:
17532 case 33:
17533 case 34:
17534 case 35:
17535 case 36:
17536 case 37:
17537 case 38:
17538 case 39:
17539 case 40:
17540 case 41:
17541 case 42:
17542 case 43:
17543 case 44:
17544 case 45:
17545 case 46:
17546 case 47:
17547 case 48:
17548 case 49:
17549 case 50:
17550 case 51:
17551 case 52:
17552 case 53:
17553 case 54:
17554 case 55:
17555 {
17556 return 200;
17557 }
17558 default:
17559 {
17560 return -1;
17561 }
17562 }
17563 }
17564 case 196:
17565 {
17566 Lexeme prevMatch = token.match;
17567 token.match = lexeme;
17568 int tokenId = GetTokenId(4);
17569 if (tokenId == CONTINUE_TOKEN)
17570 {
17571 token.id = tokenId;
17572 return -1;
17573 }
17574 else if (tokenId != INVALID_TOKEN)
17575 {
17576 token.id = tokenId;
17577 }
17578 else
17579 {
17580 token.match = prevMatch;
17581 }
17582 switch (i)
17583 {
17584 case 0:
17585 {
17586 return 193;
17587 }
17588 case 1:
17589 {
17590 return 194;
17591 }
17592 case 4:
17593 {
17594 return 197;
17595 }
17596 case 2:
17597 case 3:
17598 case 5:
17599 case 6:
17600 case 7:
17601 case 8:
17602 case 9:
17603 case 10:
17604 case 11:
17605 case 12:
17606 case 13:
17607 case 14:
17608 case 15:
17609 case 16:
17610 case 17:
17611 case 18:
17612 case 19:
17613 case 20:
17614 case 21:
17615 case 22:
17616 case 23:
17617 case 24:
17618 case 25:
17619 case 26:
17620 case 27:
17621 case 28:
17622 case 29:
17623 case 30:
17624 case 31:
17625 case 32:
17626 case 33:
17627 case 34:
17628 case 35:
17629 case 36:
17630 case 38:
17631 case 39:
17632 case 40:
17633 case 41:
17634 case 42:
17635 case 43:
17636 case 44:
17637 case 45:
17638 case 46:
17639 case 47:
17640 case 48:
17641 case 49:
17642 case 50:
17643 case 51:
17644 case 52:
17645 case 53:
17646 case 54:
17647 case 55:
17648 {
17649 return 200;
17650 }
17651 case 37:
17652 {
17653 return 202;
17654 }
17655 default:
17656 {
17657 return -1;
17658 }
17659 }
17660 }
17661 case 202:
17662 {
17663 Lexeme prevMatch = token.match;
17664 token.match = lexeme;
17665 int tokenId = GetTokenId(4);
17666 if (tokenId == CONTINUE_TOKEN)
17667 {
17668 token.id = tokenId;
17669 return -1;
17670 }
17671 else if (tokenId != INVALID_TOKEN)
17672 {
17673 token.id = tokenId;
17674 }
17675 else
17676 {
17677 token.match = prevMatch;
17678 }
17679 switch (i)
17680 {
17681 case 0:
17682 {
17683 return 193;
17684 }
17685 case 1:
17686 {
17687 return 194;
17688 }
17689 case 4:
17690 {
17691 return 197;
17692 }
17693 case 2:
17694 case 3:
17695 case 5:
17696 case 6:
17697 case 7:
17698 case 8:
17699 case 9:
17700 case 10:
17701 case 11:
17702 case 12:
17703 case 13:
17704 case 14:
17705 case 15:
17706 case 16:
17707 case 17:
17708 case 18:
17709 case 19:
17710 case 20:
17711 case 21:
17712 case 22:
17713 case 23:
17714 case 24:
17715 case 25:
17716 case 26:
17717 case 27:
17718 case 28:
17719 case 29:
17720 case 30:
17721 case 31:
17722 case 32:
17723 case 33:
17724 case 34:
17725 case 35:
17726 case 36:
17727 case 37:
17728 case 38:
17729 case 39:
17730 case 40:
17731 case 41:
17732 case 42:
17733 case 43:
17734 case 44:
17735 case 45:
17736 case 46:
17737 case 47:
17738 case 48:
17739 case 49:
17740 case 50:
17741 case 51:
17742 case 52:
17743 case 53:
17744 case 54:
17745 case 55:
17746 {
17747 return 200;
17748 }
17749 default:
17750 {
17751 return -1;
17752 }
17753 }
17754 }
17755 case 195:
17756 {
17757 switch (i)
17758 {
17759 case 0:
17760 {
17761 return 193;
17762 }
17763 case 1:
17764 {
17765 return 194;
17766 }
17767 case 4:
17768 {
17769 return 197;
17770 }
17771 case 2:
17772 case 3:
17773 case 5:
17774 case 6:
17775 case 7:
17776 case 8:
17777 case 9:
17778 case 10:
17779 case 11:
17780 case 12:
17781 case 13:
17782 case 14:
17783 case 15:
17784 case 16:
17785 case 17:
17786 case 18:
17787 case 19:
17788 case 20:
17789 case 21:
17790 case 22:
17791 case 23:
17792 case 24:
17793 case 25:
17794 case 26:
17795 case 27:
17796 case 28:
17797 case 29:
17798 case 30:
17799 case 31:
17800 case 32:
17801 case 33:
17802 case 34:
17803 case 35:
17804 case 36:
17805 case 37:
17806 case 38:
17807 case 39:
17808 case 40:
17809 case 41:
17810 case 42:
17811 case 43:
17812 case 44:
17813 case 45:
17814 case 46:
17815 case 47:
17816 case 48:
17817 case 49:
17818 case 50:
17819 case 51:
17820 case 52:
17821 case 53:
17822 case 54:
17823 case 55:
17824 {
17825 return 200;
17826 }
17827 default:
17828 {
17829 return -1;
17830 }
17831 }
17832 }
17833 case 194:
17834 {
17835 Lexeme prevMatch = token.match;
17836 token.match = lexeme;
17837 int tokenId = GetTokenId(3);
17838 if (tokenId == CONTINUE_TOKEN)
17839 {
17840 token.id = tokenId;
17841 return -1;
17842 }
17843 else if (tokenId != INVALID_TOKEN)
17844 {
17845 token.id = tokenId;
17846 }
17847 else
17848 {
17849 token.match = prevMatch;
17850 }
17851 switch (i)
17852 {
17853 case 37:
17854 {
17855 return 203;
17856 }
17857 default:
17858 {
17859 return -1;
17860 }
17861 }
17862 }
17863 case 203:
17864 {
17865 Lexeme prevMatch = token.match;
17866 token.match = lexeme;
17867 int tokenId = GetTokenId(3);
17868 if (tokenId == CONTINUE_TOKEN)
17869 {
17870 token.id = tokenId;
17871 return -1;
17872 }
17873 else if (tokenId != INVALID_TOKEN)
17874 {
17875 token.id = tokenId;
17876 }
17877 else
17878 {
17879 token.match = prevMatch;
17880 }
17881 switch (i)
17882 {
17883 case 37:
17884 {
17885 return 204;
17886 }
17887 default:
17888 {
17889 return -1;
17890 }
17891 }
17892 }
17893 case 204:
17894 {
17895 Lexeme prevMatch = token.match;
17896 token.match = lexeme;
17897 int tokenId = GetTokenId(3);
17898 if (tokenId == CONTINUE_TOKEN)
17899 {
17900 token.id = tokenId;
17901 return -1;
17902 }
17903 else if (tokenId != INVALID_TOKEN)
17904 {
17905 token.id = tokenId;
17906 }
17907 else
17908 {
17909 token.match = prevMatch;
17910 }
17911 switch (i)
17912 {
17913 case 37:
17914 {
17915 return 205;
17916 }
17917 default:
17918 {
17919 return -1;
17920 }
17921 }
17922 }
17923 case 205:
17924 {
17925 Lexeme prevMatch = token.match;
17926 token.match = lexeme;
17927 int tokenId = GetTokenId(3);
17928 if (tokenId == CONTINUE_TOKEN)
17929 {
17930 token.id = tokenId;
17931 return -1;
17932 }
17933 else if (tokenId != INVALID_TOKEN)
17934 {
17935 token.id = tokenId;
17936 }
17937 else
17938 {
17939 token.match = prevMatch;
17940 }
17941 return -1;
17942 }
17943 case 193:
17944 {
17945 Lexeme prevMatch = token.match;
17946 token.match = lexeme;
17947 int tokenId = GetTokenId(3);
17948 if (tokenId == CONTINUE_TOKEN)
17949 {
17950 token.id = tokenId;
17951 return -1;
17952 }
17953 else if (tokenId != INVALID_TOKEN)
17954 {
17955 token.id = tokenId;
17956 }
17957 else
17958 {
17959 token.match = prevMatch;
17960 }
17961 switch (i)
17962 {
17963 case 37:
17964 {
17965 return 204;
17966 }
17967 case 1:
17968 {
17969 return 206;
17970 }
17971 default:
17972 {
17973 return -1;
17974 }
17975 }
17976 }
17977 case 206:
17978 {
17979 Lexeme prevMatch = token.match;
17980 token.match = lexeme;
17981 int tokenId = GetTokenId(3);
17982 if (tokenId == CONTINUE_TOKEN)
17983 {
17984 token.id = tokenId;
17985 return -1;
17986 }
17987 else if (tokenId != INVALID_TOKEN)
17988 {
17989 token.id = tokenId;
17990 }
17991 else
17992 {
17993 token.match = prevMatch;
17994 }
17995 switch (i)
17996 {
17997 case 37:
17998 {
17999 return 203;
18000 }
18001 default:
18002 {
18003 return -1;
18004 }
18005 }
18006 }
18007 case 190:
18008 {
18009 switch (i)
18010 {
18011 case 0:
18012 {
18013 return 207;
18014 }
18015 case 1:
18016 {
18017 return 208;
18018 }
18019 case 2:
18020 case 3:
18021 case 5:
18022 case 6:
18023 case 7:
18024 case 8:
18025 case 9:
18026 case 10:
18027 case 11:
18028 case 12:
18029 case 13:
18030 case 14:
18031 case 15:
18032 case 16:
18033 case 17:
18034 case 18:
18035 case 19:
18036 case 20:
18037 case 21:
18038 case 22:
18039 case 23:
18040 case 24:
18041 case 25:
18042 case 26:
18043 case 27:
18044 case 28:
18045 case 29:
18046 case 30:
18047 case 31:
18048 case 32:
18049 case 33:
18050 case 34:
18051 case 35:
18052 case 36:
18053 case 37:
18054 case 38:
18055 case 39:
18056 case 40:
18057 case 41:
18058 case 42:
18059 case 43:
18060 case 44:
18061 case 45:
18062 case 46:
18063 case 47:
18064 case 48:
18065 case 49:
18066 case 50:
18067 case 51:
18068 case 52:
18069 case 53:
18070 case 54:
18071 case 55:
18072 {
18073 return 209;
18074 }
18075 case 4:
18076 {
18077 return 210;
18078 }
18079 default:
18080 {
18081 return -1;
18082 }
18083 }
18084 }
18085 case 210:
18086 {
18087 switch (i)
18088 {
18089 case 0:
18090 {
18091 return 207;
18092 }
18093 case 1:
18094 {
18095 return 208;
18096 }
18097 case 4:
18098 {
18099 return 210;
18100 }
18101 case 2:
18102 case 5:
18103 case 6:
18104 case 7:
18105 case 8:
18106 case 9:
18107 case 10:
18108 case 11:
18109 case 12:
18110 case 13:
18111 case 14:
18112 case 15:
18113 case 16:
18114 case 17:
18115 case 18:
18116 case 19:
18117 case 20:
18118 case 21:
18119 case 22:
18120 case 23:
18121 case 24:
18122 case 25:
18123 case 26:
18124 case 27:
18125 case 28:
18126 case 29:
18127 case 30:
18128 case 31:
18129 case 32:
18130 case 33:
18131 case 34:
18132 case 35:
18133 case 36:
18134 case 37:
18135 case 38:
18136 case 39:
18137 case 40:
18138 case 41:
18139 case 42:
18140 case 43:
18141 case 44:
18142 case 45:
18143 case 46:
18144 case 47:
18145 case 48:
18146 case 49:
18147 case 50:
18148 case 51:
18149 case 52:
18150 case 53:
18151 case 54:
18152 case 55:
18153 {
18154 return 211;
18155 }
18156 case 3:
18157 {
18158 return 212;
18159 }
18160 default:
18161 {
18162 return -1;
18163 }
18164 }
18165 }
18166 case 212:
18167 {
18168 Lexeme prevMatch = token.match;
18169 token.match = lexeme;
18170 int tokenId = GetTokenId(4);
18171 if (tokenId == CONTINUE_TOKEN)
18172 {
18173 token.id = tokenId;
18174 return -1;
18175 }
18176 else if (tokenId != INVALID_TOKEN)
18177 {
18178 token.id = tokenId;
18179 }
18180 else
18181 {
18182 token.match = prevMatch;
18183 }
18184 switch (i)
18185 {
18186 case 0:
18187 {
18188 return 207;
18189 }
18190 case 1:
18191 {
18192 return 208;
18193 }
18194 case 2:
18195 case 3:
18196 case 5:
18197 case 6:
18198 case 7:
18199 case 8:
18200 case 9:
18201 case 10:
18202 case 11:
18203 case 12:
18204 case 13:
18205 case 14:
18206 case 15:
18207 case 16:
18208 case 17:
18209 case 18:
18210 case 19:
18211 case 20:
18212 case 21:
18213 case 22:
18214 case 23:
18215 case 24:
18216 case 25:
18217 case 26:
18218 case 27:
18219 case 28:
18220 case 29:
18221 case 30:
18222 case 31:
18223 case 32:
18224 case 33:
18225 case 34:
18226 case 35:
18227 case 36:
18228 case 38:
18229 case 39:
18230 case 40:
18231 case 41:
18232 case 42:
18233 case 43:
18234 case 44:
18235 case 45:
18236 case 46:
18237 case 47:
18238 case 48:
18239 case 49:
18240 case 50:
18241 case 51:
18242 case 52:
18243 case 53:
18244 case 54:
18245 case 55:
18246 {
18247 return 209;
18248 }
18249 case 4:
18250 {
18251 return 210;
18252 }
18253 case 37:
18254 {
18255 return 213;
18256 }
18257 default:
18258 {
18259 return -1;
18260 }
18261 }
18262 }
18263 case 213:
18264 {
18265 Lexeme prevMatch = token.match;
18266 token.match = lexeme;
18267 int tokenId = GetTokenId(4);
18268 if (tokenId == CONTINUE_TOKEN)
18269 {
18270 token.id = tokenId;
18271 return -1;
18272 }
18273 else if (tokenId != INVALID_TOKEN)
18274 {
18275 token.id = tokenId;
18276 }
18277 else
18278 {
18279 token.match = prevMatch;
18280 }
18281 switch (i)
18282 {
18283 case 0:
18284 {
18285 return 207;
18286 }
18287 case 1:
18288 {
18289 return 208;
18290 }
18291 case 2:
18292 case 3:
18293 case 5:
18294 case 6:
18295 case 7:
18296 case 8:
18297 case 9:
18298 case 10:
18299 case 11:
18300 case 12:
18301 case 13:
18302 case 14:
18303 case 15:
18304 case 16:
18305 case 17:
18306 case 18:
18307 case 19:
18308 case 20:
18309 case 21:
18310 case 22:
18311 case 23:
18312 case 24:
18313 case 25:
18314 case 26:
18315 case 27:
18316 case 28:
18317 case 29:
18318 case 30:
18319 case 31:
18320 case 32:
18321 case 33:
18322 case 34:
18323 case 35:
18324 case 36:
18325 case 37:
18326 case 38:
18327 case 39:
18328 case 40:
18329 case 41:
18330 case 42:
18331 case 43:
18332 case 44:
18333 case 45:
18334 case 46:
18335 case 47:
18336 case 48:
18337 case 49:
18338 case 50:
18339 case 51:
18340 case 52:
18341 case 53:
18342 case 54:
18343 case 55:
18344 {
18345 return 209;
18346 }
18347 case 4:
18348 {
18349 return 210;
18350 }
18351 default:
18352 {
18353 return -1;
18354 }
18355 }
18356 }
18357 case 211:
18358 {
18359 switch (i)
18360 {
18361 case 0:
18362 {
18363 return 207;
18364 }
18365 case 1:
18366 {
18367 return 208;
18368 }
18369 case 2:
18370 case 3:
18371 case 5:
18372 case 6:
18373 case 7:
18374 case 8:
18375 case 9:
18376 case 10:
18377 case 11:
18378 case 12:
18379 case 13:
18380 case 14:
18381 case 15:
18382 case 16:
18383 case 17:
18384 case 18:
18385 case 19:
18386 case 20:
18387 case 21:
18388 case 22:
18389 case 23:
18390 case 24:
18391 case 25:
18392 case 26:
18393 case 27:
18394 case 28:
18395 case 29:
18396 case 30:
18397 case 31:
18398 case 32:
18399 case 33:
18400 case 34:
18401 case 35:
18402 case 36:
18403 case 37:
18404 case 38:
18405 case 39:
18406 case 40:
18407 case 41:
18408 case 42:
18409 case 43:
18410 case 44:
18411 case 45:
18412 case 46:
18413 case 47:
18414 case 48:
18415 case 49:
18416 case 50:
18417 case 51:
18418 case 52:
18419 case 53:
18420 case 54:
18421 case 55:
18422 {
18423 return 209;
18424 }
18425 case 4:
18426 {
18427 return 210;
18428 }
18429 default:
18430 {
18431 return -1;
18432 }
18433 }
18434 }
18435 case 209:
18436 {
18437 switch (i)
18438 {
18439 case 0:
18440 {
18441 return 207;
18442 }
18443 case 1:
18444 {
18445 return 208;
18446 }
18447 case 2:
18448 case 3:
18449 case 5:
18450 case 6:
18451 case 7:
18452 case 8:
18453 case 9:
18454 case 10:
18455 case 11:
18456 case 12:
18457 case 13:
18458 case 14:
18459 case 15:
18460 case 16:
18461 case 17:
18462 case 18:
18463 case 19:
18464 case 20:
18465 case 21:
18466 case 22:
18467 case 23:
18468 case 24:
18469 case 25:
18470 case 26:
18471 case 27:
18472 case 28:
18473 case 29:
18474 case 30:
18475 case 31:
18476 case 32:
18477 case 33:
18478 case 34:
18479 case 35:
18480 case 36:
18481 case 37:
18482 case 38:
18483 case 39:
18484 case 40:
18485 case 41:
18486 case 42:
18487 case 43:
18488 case 44:
18489 case 45:
18490 case 46:
18491 case 47:
18492 case 48:
18493 case 49:
18494 case 50:
18495 case 51:
18496 case 52:
18497 case 53:
18498 case 54:
18499 case 55:
18500 {
18501 return 209;
18502 }
18503 case 4:
18504 {
18505 return 210;
18506 }
18507 default:
18508 {
18509 return -1;
18510 }
18511 }
18512 }
18513 case 208:
18514 {
18515 Lexeme prevMatch = token.match;
18516 token.match = lexeme;
18517 int tokenId = GetTokenId(2);
18518 if (tokenId == CONTINUE_TOKEN)
18519 {
18520 token.id = tokenId;
18521 return -1;
18522 }
18523 else if (tokenId != INVALID_TOKEN)
18524 {
18525 token.id = tokenId;
18526 }
18527 else
18528 {
18529 token.match = prevMatch;
18530 }
18531 switch (i)
18532 {
18533 case 37:
18534 {
18535 return 214;
18536 }
18537 default:
18538 {
18539 return -1;
18540 }
18541 }
18542 }
18543 case 214:
18544 {
18545 Lexeme prevMatch = token.match;
18546 token.match = lexeme;
18547 int tokenId = GetTokenId(2);
18548 if (tokenId == CONTINUE_TOKEN)
18549 {
18550 token.id = tokenId;
18551 return -1;
18552 }
18553 else if (tokenId != INVALID_TOKEN)
18554 {
18555 token.id = tokenId;
18556 }
18557 else
18558 {
18559 token.match = prevMatch;
18560 }
18561 switch (i)
18562 {
18563 case 37:
18564 {
18565 return 215;
18566 }
18567 default:
18568 {
18569 return -1;
18570 }
18571 }
18572 }
18573 case 215:
18574 {
18575 Lexeme prevMatch = token.match;
18576 token.match = lexeme;
18577 int tokenId = GetTokenId(2);
18578 if (tokenId == CONTINUE_TOKEN)
18579 {
18580 token.id = tokenId;
18581 return -1;
18582 }
18583 else if (tokenId != INVALID_TOKEN)
18584 {
18585 token.id = tokenId;
18586 }
18587 else
18588 {
18589 token.match = prevMatch;
18590 }
18591 switch (i)
18592 {
18593 case 37:
18594 {
18595 return 47;
18596 }
18597 default:
18598 {
18599 return -1;
18600 }
18601 }
18602 }
18603 case 207:
18604 {
18605 Lexeme prevMatch = token.match;
18606 token.match = lexeme;
18607 int tokenId = GetTokenId(2);
18608 if (tokenId == CONTINUE_TOKEN)
18609 {
18610 token.id = tokenId;
18611 return -1;
18612 }
18613 else if (tokenId != INVALID_TOKEN)
18614 {
18615 token.id = tokenId;
18616 }
18617 else
18618 {
18619 token.match = prevMatch;
18620 }
18621 switch (i)
18622 {
18623 case 37:
18624 {
18625 return 215;
18626 }
18627 case 1:
18628 {
18629 return 216;
18630 }
18631 default:
18632 {
18633 return -1;
18634 }
18635 }
18636 }
18637 case 216:
18638 {
18639 Lexeme prevMatch = token.match;
18640 token.match = lexeme;
18641 int tokenId = GetTokenId(2);
18642 if (tokenId == CONTINUE_TOKEN)
18643 {
18644 token.id = tokenId;
18645 return -1;
18646 }
18647 else if (tokenId != INVALID_TOKEN)
18648 {
18649 token.id = tokenId;
18650 }
18651 else
18652 {
18653 token.match = prevMatch;
18654 }
18655 switch (i)
18656 {
18657 case 37:
18658 {
18659 return 214;
18660 }
18661 default:
18662 {
18663 return -1;
18664 }
18665 }
18666 }
18667 case 3:
18668 {
18669 switch (i)
18670 {
18671 case 0:
18672 {
18673 return 39;
18674 }
18675 case 1:
18676 {
18677 return 40;
18678 }
18679 case 2:
18680 {
18681 return 217;
18682 }
18683 case 3:
18684 case 5:
18685 case 6:
18686 case 7:
18687 case 9:
18688 case 10:
18689 case 11:
18690 case 12:
18691 case 13:
18692 case 14:
18693 case 15:
18694 case 16:
18695 case 17:
18696 case 18:
18697 case 19:
18698 case 20:
18699 case 21:
18700 case 22:
18701 case 23:
18702 case 24:
18703 case 25:
18704 case 26:
18705 case 27:
18706 case 28:
18707 case 29:
18708 case 30:
18709 case 31:
18710 case 32:
18711 case 33:
18712 case 34:
18713 case 35:
18714 case 36:
18715 case 37:
18716 case 38:
18717 case 39:
18718 case 40:
18719 case 41:
18720 case 42:
18721 case 43:
18722 case 44:
18723 case 45:
18724 case 46:
18725 case 47:
18726 case 48:
18727 case 49:
18728 case 50:
18729 case 51:
18730 case 52:
18731 case 53:
18732 case 54:
18733 case 55:
18734 {
18735 return 218;
18736 }
18737 case 4:
18738 {
18739 return 219;
18740 }
18741 case 8:
18742 {
18743 return 220;
18744 }
18745 default:
18746 {
18747 return -1;
18748 }
18749 }
18750 }
18751 case 220:
18752 {
18753 switch (i)
18754 {
18755 case 3:
18756 case 5:
18757 case 6:
18758 case 7:
18759 case 11:
18760 case 12:
18761 case 13:
18762 case 14:
18763 case 17:
18764 case 23:
18765 case 24:
18766 case 25:
18767 case 26:
18768 case 28:
18769 case 32:
18770 case 33:
18771 case 34:
18772 case 35:
18773 case 36:
18774 case 37:
18775 case 38:
18776 case 39:
18777 case 40:
18778 case 41:
18779 case 42:
18780 case 43:
18781 case 44:
18782 case 45:
18783 case 46:
18784 case 47:
18785 case 48:
18786 case 49:
18787 case 50:
18788 case 51:
18789 case 52:
18790 case 53:
18791 case 54:
18792 case 55:
18793 {
18794 return 7;
18795 }
18796 case 0:
18797 {
18798 return 39;
18799 }
18800 case 1:
18801 {
18802 return 40;
18803 }
18804 case 4:
18805 {
18806 return 41;
18807 }
18808 case 2:
18809 case 8:
18810 case 9:
18811 case 10:
18812 case 19:
18813 case 20:
18814 case 21:
18815 case 22:
18816 case 29:
18817 case 30:
18818 case 31:
18819 {
18820 return 221;
18821 }
18822 case 15:
18823 {
18824 return 222;
18825 }
18826 case 16:
18827 {
18828 return 223;
18829 }
18830 case 18:
18831 {
18832 return 224;
18833 }
18834 case 27:
18835 {
18836 return 225;
18837 }
18838 default:
18839 {
18840 return -1;
18841 }
18842 }
18843 }
18844 case 225:
18845 {
18846 switch (i)
18847 {
18848 case 0:
18849 {
18850 return 39;
18851 }
18852 case 1:
18853 {
18854 return 40;
18855 }
18856 case 2:
18857 {
18858 return 217;
18859 }
18860 case 3:
18861 case 5:
18862 case 6:
18863 case 7:
18864 case 9:
18865 case 10:
18866 case 11:
18867 case 12:
18868 case 13:
18869 case 14:
18870 case 15:
18871 case 16:
18872 case 17:
18873 case 18:
18874 case 19:
18875 case 20:
18876 case 21:
18877 case 22:
18878 case 23:
18879 case 24:
18880 case 25:
18881 case 26:
18882 case 28:
18883 case 29:
18884 case 30:
18885 case 31:
18886 case 32:
18887 case 33:
18888 case 34:
18889 case 35:
18890 case 36:
18891 case 38:
18892 case 39:
18893 case 40:
18894 case 41:
18895 case 42:
18896 case 43:
18897 case 44:
18898 case 45:
18899 case 46:
18900 case 47:
18901 case 48:
18902 case 49:
18903 case 50:
18904 case 51:
18905 case 52:
18906 case 53:
18907 case 54:
18908 case 55:
18909 {
18910 return 218;
18911 }
18912 case 4:
18913 {
18914 return 219;
18915 }
18916 case 8:
18917 {
18918 return 220;
18919 }
18920 case 27:
18921 {
18922 return 226;
18923 }
18924 case 37:
18925 {
18926 return 227;
18927 }
18928 default:
18929 {
18930 return -1;
18931 }
18932 }
18933 }
18934 case 227:
18935 {
18936 switch (i)
18937 {
18938 case 0:
18939 {
18940 return 39;
18941 }
18942 case 1:
18943 {
18944 return 40;
18945 }
18946 case 2:
18947 {
18948 return 217;
18949 }
18950 case 3:
18951 case 5:
18952 case 6:
18953 case 7:
18954 case 9:
18955 case 10:
18956 case 11:
18957 case 12:
18958 case 13:
18959 case 14:
18960 case 15:
18961 case 16:
18962 case 17:
18963 case 18:
18964 case 19:
18965 case 20:
18966 case 21:
18967 case 22:
18968 case 23:
18969 case 24:
18970 case 25:
18971 case 26:
18972 case 27:
18973 case 28:
18974 case 29:
18975 case 30:
18976 case 31:
18977 case 32:
18978 case 33:
18979 case 34:
18980 case 35:
18981 case 36:
18982 case 38:
18983 case 39:
18984 case 40:
18985 case 41:
18986 case 42:
18987 case 43:
18988 case 44:
18989 case 45:
18990 case 46:
18991 case 47:
18992 case 48:
18993 case 49:
18994 case 50:
18995 case 51:
18996 case 52:
18997 case 53:
18998 case 54:
18999 case 55:
19000 {
19001 return 218;
19002 }
19003 case 4:
19004 {
19005 return 219;
19006 }
19007 case 8:
19008 {
19009 return 220;
19010 }
19011 case 37:
19012 {
19013 return 228;
19014 }
19015 default:
19016 {
19017 return -1;
19018 }
19019 }
19020 }
19021 case 228:
19022 {
19023 switch (i)
19024 {
19025 case 0:
19026 {
19027 return 39;
19028 }
19029 case 1:
19030 {
19031 return 40;
19032 }
19033 case 2:
19034 {
19035 return 217;
19036 }
19037 case 3:
19038 case 5:
19039 case 6:
19040 case 7:
19041 case 9:
19042 case 10:
19043 case 11:
19044 case 12:
19045 case 13:
19046 case 14:
19047 case 15:
19048 case 16:
19049 case 17:
19050 case 18:
19051 case 19:
19052 case 20:
19053 case 21:
19054 case 22:
19055 case 23:
19056 case 24:
19057 case 25:
19058 case 26:
19059 case 27:
19060 case 28:
19061 case 29:
19062 case 30:
19063 case 31:
19064 case 32:
19065 case 33:
19066 case 34:
19067 case 35:
19068 case 36:
19069 case 38:
19070 case 39:
19071 case 40:
19072 case 41:
19073 case 42:
19074 case 43:
19075 case 44:
19076 case 45:
19077 case 46:
19078 case 47:
19079 case 48:
19080 case 49:
19081 case 50:
19082 case 51:
19083 case 52:
19084 case 53:
19085 case 54:
19086 case 55:
19087 {
19088 return 218;
19089 }
19090 case 4:
19091 {
19092 return 219;
19093 }
19094 case 8:
19095 {
19096 return 220;
19097 }
19098 case 37:
19099 {
19100 return 229;
19101 }
19102 default:
19103 {
19104 return -1;
19105 }
19106 }
19107 }
19108 case 229:
19109 {
19110 switch (i)
19111 {
19112 case 0:
19113 {
19114 return 39;
19115 }
19116 case 1:
19117 {
19118 return 40;
19119 }
19120 case 2:
19121 {
19122 return 217;
19123 }
19124 case 3:
19125 case 5:
19126 case 6:
19127 case 7:
19128 case 9:
19129 case 10:
19130 case 11:
19131 case 12:
19132 case 13:
19133 case 14:
19134 case 15:
19135 case 16:
19136 case 17:
19137 case 18:
19138 case 19:
19139 case 20:
19140 case 21:
19141 case 22:
19142 case 23:
19143 case 24:
19144 case 25:
19145 case 26:
19146 case 27:
19147 case 28:
19148 case 29:
19149 case 30:
19150 case 31:
19151 case 32:
19152 case 33:
19153 case 34:
19154 case 35:
19155 case 36:
19156 case 38:
19157 case 39:
19158 case 40:
19159 case 41:
19160 case 42:
19161 case 43:
19162 case 44:
19163 case 45:
19164 case 46:
19165 case 47:
19166 case 48:
19167 case 49:
19168 case 50:
19169 case 51:
19170 case 52:
19171 case 53:
19172 case 54:
19173 case 55:
19174 {
19175 return 218;
19176 }
19177 case 4:
19178 {
19179 return 219;
19180 }
19181 case 8:
19182 {
19183 return 220;
19184 }
19185 case 37:
19186 {
19187 return 230;
19188 }
19189 default:
19190 {
19191 return -1;
19192 }
19193 }
19194 }
19195 case 230:
19196 {
19197 switch (i)
19198 {
19199 case 0:
19200 {
19201 return 39;
19202 }
19203 case 1:
19204 {
19205 return 40;
19206 }
19207 case 2:
19208 {
19209 return 217;
19210 }
19211 case 3:
19212 case 5:
19213 case 6:
19214 case 7:
19215 case 9:
19216 case 10:
19217 case 11:
19218 case 12:
19219 case 13:
19220 case 14:
19221 case 15:
19222 case 16:
19223 case 17:
19224 case 18:
19225 case 19:
19226 case 20:
19227 case 21:
19228 case 22:
19229 case 23:
19230 case 24:
19231 case 25:
19232 case 26:
19233 case 27:
19234 case 28:
19235 case 29:
19236 case 30:
19237 case 31:
19238 case 32:
19239 case 33:
19240 case 34:
19241 case 35:
19242 case 36:
19243 case 37:
19244 case 38:
19245 case 39:
19246 case 40:
19247 case 41:
19248 case 42:
19249 case 43:
19250 case 44:
19251 case 45:
19252 case 46:
19253 case 47:
19254 case 48:
19255 case 49:
19256 case 50:
19257 case 51:
19258 case 52:
19259 case 53:
19260 case 54:
19261 case 55:
19262 {
19263 return 218;
19264 }
19265 case 4:
19266 {
19267 return 219;
19268 }
19269 case 8:
19270 {
19271 return 220;
19272 }
19273 default:
19274 {
19275 return -1;
19276 }
19277 }
19278 }
19279 case 226:
19280 {
19281 switch (i)
19282 {
19283 case 0:
19284 {
19285 return 39;
19286 }
19287 case 1:
19288 {
19289 return 40;
19290 }
19291 case 2:
19292 {
19293 return 217;
19294 }
19295 case 3:
19296 case 5:
19297 case 6:
19298 case 7:
19299 case 9:
19300 case 10:
19301 case 11:
19302 case 12:
19303 case 13:
19304 case 14:
19305 case 15:
19306 case 16:
19307 case 17:
19308 case 18:
19309 case 19:
19310 case 20:
19311 case 21:
19312 case 22:
19313 case 23:
19314 case 24:
19315 case 25:
19316 case 26:
19317 case 28:
19318 case 29:
19319 case 30:
19320 case 31:
19321 case 32:
19322 case 33:
19323 case 34:
19324 case 35:
19325 case 36:
19326 case 38:
19327 case 39:
19328 case 40:
19329 case 41:
19330 case 42:
19331 case 43:
19332 case 44:
19333 case 45:
19334 case 46:
19335 case 47:
19336 case 48:
19337 case 49:
19338 case 50:
19339 case 51:
19340 case 52:
19341 case 53:
19342 case 54:
19343 case 55:
19344 {
19345 return 218;
19346 }
19347 case 4:
19348 {
19349 return 219;
19350 }
19351 case 8:
19352 {
19353 return 220;
19354 }
19355 case 37:
19356 {
19357 return 227;
19358 }
19359 case 27:
19360 {
19361 return 231;
19362 }
19363 default:
19364 {
19365 return -1;
19366 }
19367 }
19368 }
19369 case 231:
19370 {
19371 switch (i)
19372 {
19373 case 0:
19374 {
19375 return 39;
19376 }
19377 case 1:
19378 {
19379 return 40;
19380 }
19381 case 2:
19382 {
19383 return 217;
19384 }
19385 case 3:
19386 case 5:
19387 case 6:
19388 case 7:
19389 case 9:
19390 case 10:
19391 case 11:
19392 case 12:
19393 case 13:
19394 case 14:
19395 case 15:
19396 case 16:
19397 case 17:
19398 case 18:
19399 case 19:
19400 case 20:
19401 case 21:
19402 case 22:
19403 case 23:
19404 case 24:
19405 case 25:
19406 case 26:
19407 case 27:
19408 case 28:
19409 case 29:
19410 case 30:
19411 case 31:
19412 case 32:
19413 case 33:
19414 case 34:
19415 case 35:
19416 case 36:
19417 case 38:
19418 case 39:
19419 case 40:
19420 case 41:
19421 case 42:
19422 case 43:
19423 case 44:
19424 case 45:
19425 case 46:
19426 case 47:
19427 case 48:
19428 case 49:
19429 case 50:
19430 case 51:
19431 case 52:
19432 case 53:
19433 case 54:
19434 case 55:
19435 {
19436 return 218;
19437 }
19438 case 4:
19439 {
19440 return 219;
19441 }
19442 case 8:
19443 {
19444 return 220;
19445 }
19446 case 37:
19447 {
19448 return 228;
19449 }
19450 default:
19451 {
19452 return -1;
19453 }
19454 }
19455 }
19456 case 224:
19457 {
19458 switch (i)
19459 {
19460 case 2:
19461 case 3:
19462 case 5:
19463 case 6:
19464 case 7:
19465 case 8:
19466 case 9:
19467 case 10:
19468 case 11:
19469 case 12:
19470 case 13:
19471 case 14:
19472 case 15:
19473 case 16:
19474 case 17:
19475 case 18:
19476 case 19:
19477 case 20:
19478 case 21:
19479 case 22:
19480 case 23:
19481 case 24:
19482 case 34:
19483 case 35:
19484 case 36:
19485 case 38:
19486 case 39:
19487 case 40:
19488 case 41:
19489 case 42:
19490 case 43:
19491 case 44:
19492 case 45:
19493 case 46:
19494 case 47:
19495 case 48:
19496 case 49:
19497 case 50:
19498 case 51:
19499 case 52:
19500 case 53:
19501 case 54:
19502 case 55:
19503 {
19504 return 7;
19505 }
19506 case 0:
19507 {
19508 return 39;
19509 }
19510 case 1:
19511 {
19512 return 40;
19513 }
19514 case 4:
19515 {
19516 return 41;
19517 }
19518 case 25:
19519 case 26:
19520 case 27:
19521 case 28:
19522 case 29:
19523 case 30:
19524 case 31:
19525 case 32:
19526 case 33:
19527 {
19528 return 232;
19529 }
19530 case 37:
19531 {
19532 return 233;
19533 }
19534 default:
19535 {
19536 return -1;
19537 }
19538 }
19539 }
19540 case 233:
19541 {
19542 switch (i)
19543 {
19544 case 2:
19545 case 3:
19546 case 5:
19547 case 6:
19548 case 7:
19549 case 8:
19550 case 9:
19551 case 10:
19552 case 11:
19553 case 12:
19554 case 13:
19555 case 14:
19556 case 15:
19557 case 16:
19558 case 17:
19559 case 18:
19560 case 19:
19561 case 20:
19562 case 21:
19563 case 22:
19564 case 23:
19565 case 24:
19566 case 34:
19567 case 35:
19568 case 36:
19569 case 37:
19570 case 38:
19571 case 39:
19572 case 40:
19573 case 41:
19574 case 42:
19575 case 43:
19576 case 44:
19577 case 45:
19578 case 46:
19579 case 47:
19580 case 48:
19581 case 49:
19582 case 50:
19583 case 51:
19584 case 52:
19585 case 53:
19586 case 54:
19587 case 55:
19588 {
19589 return 7;
19590 }
19591 case 0:
19592 {
19593 return 39;
19594 }
19595 case 1:
19596 {
19597 return 40;
19598 }
19599 case 4:
19600 {
19601 return 41;
19602 }
19603 case 25:
19604 case 26:
19605 case 27:
19606 case 28:
19607 case 29:
19608 case 30:
19609 case 31:
19610 case 32:
19611 case 33:
19612 {
19613 return 232;
19614 }
19615 default:
19616 {
19617 return -1;
19618 }
19619 }
19620 }
19621 case 232:
19622 {
19623 switch (i)
19624 {
19625 case 0:
19626 {
19627 return 39;
19628 }
19629 case 1:
19630 {
19631 return 40;
19632 }
19633 case 2:
19634 {
19635 return 217;
19636 }
19637 case 3:
19638 case 5:
19639 case 6:
19640 case 7:
19641 case 9:
19642 case 10:
19643 case 11:
19644 case 12:
19645 case 13:
19646 case 14:
19647 case 15:
19648 case 16:
19649 case 17:
19650 case 18:
19651 case 19:
19652 case 20:
19653 case 21:
19654 case 22:
19655 case 23:
19656 case 24:
19657 case 34:
19658 case 35:
19659 case 36:
19660 case 38:
19661 case 39:
19662 case 40:
19663 case 41:
19664 case 42:
19665 case 43:
19666 case 44:
19667 case 45:
19668 case 46:
19669 case 47:
19670 case 48:
19671 case 49:
19672 case 50:
19673 case 51:
19674 case 52:
19675 case 53:
19676 case 54:
19677 case 55:
19678 {
19679 return 218;
19680 }
19681 case 4:
19682 {
19683 return 219;
19684 }
19685 case 8:
19686 {
19687 return 220;
19688 }
19689 case 25:
19690 case 26:
19691 case 27:
19692 case 28:
19693 case 29:
19694 case 30:
19695 case 31:
19696 case 32:
19697 case 33:
19698 {
19699 return 232;
19700 }
19701 case 37:
19702 {
19703 return 234;
19704 }
19705 default:
19706 {
19707 return -1;
19708 }
19709 }
19710 }
19711 case 234:
19712 {
19713 switch (i)
19714 {
19715 case 0:
19716 {
19717 return 39;
19718 }
19719 case 1:
19720 {
19721 return 40;
19722 }
19723 case 2:
19724 {
19725 return 217;
19726 }
19727 case 3:
19728 case 5:
19729 case 6:
19730 case 7:
19731 case 9:
19732 case 10:
19733 case 11:
19734 case 12:
19735 case 13:
19736 case 14:
19737 case 15:
19738 case 16:
19739 case 17:
19740 case 18:
19741 case 19:
19742 case 20:
19743 case 21:
19744 case 22:
19745 case 23:
19746 case 24:
19747 case 34:
19748 case 35:
19749 case 36:
19750 case 38:
19751 case 39:
19752 case 40:
19753 case 41:
19754 case 42:
19755 case 43:
19756 case 44:
19757 case 45:
19758 case 46:
19759 case 47:
19760 case 48:
19761 case 49:
19762 case 50:
19763 case 51:
19764 case 52:
19765 case 53:
19766 case 54:
19767 case 55:
19768 {
19769 return 218;
19770 }
19771 case 4:
19772 {
19773 return 219;
19774 }
19775 case 8:
19776 {
19777 return 220;
19778 }
19779 case 37:
19780 {
19781 return 230;
19782 }
19783 case 25:
19784 case 26:
19785 case 27:
19786 case 28:
19787 case 29:
19788 case 30:
19789 case 31:
19790 case 32:
19791 case 33:
19792 {
19793 return 232;
19794 }
19795 default:
19796 {
19797 return -1;
19798 }
19799 }
19800 }
19801 case 223:
19802 {
19803 switch (i)
19804 {
19805 case 2:
19806 case 3:
19807 case 5:
19808 case 6:
19809 case 7:
19810 case 8:
19811 case 9:
19812 case 10:
19813 case 11:
19814 case 12:
19815 case 13:
19816 case 14:
19817 case 15:
19818 case 16:
19819 case 17:
19820 case 18:
19821 case 19:
19822 case 20:
19823 case 21:
19824 case 22:
19825 case 23:
19826 case 24:
19827 case 34:
19828 case 35:
19829 case 36:
19830 case 37:
19831 case 38:
19832 case 39:
19833 case 40:
19834 case 41:
19835 case 42:
19836 case 43:
19837 case 44:
19838 case 45:
19839 case 46:
19840 case 47:
19841 case 48:
19842 case 49:
19843 case 50:
19844 case 51:
19845 case 52:
19846 case 53:
19847 case 54:
19848 case 55:
19849 {
19850 return 7;
19851 }
19852 case 0:
19853 {
19854 return 39;
19855 }
19856 case 1:
19857 {
19858 return 40;
19859 }
19860 case 4:
19861 {
19862 return 41;
19863 }
19864 case 25:
19865 case 26:
19866 case 27:
19867 case 28:
19868 case 29:
19869 case 30:
19870 case 31:
19871 case 32:
19872 case 33:
19873 {
19874 return 235;
19875 }
19876 default:
19877 {
19878 return -1;
19879 }
19880 }
19881 }
19882 case 235:
19883 {
19884 switch (i)
19885 {
19886 case 2:
19887 case 3:
19888 case 5:
19889 case 6:
19890 case 7:
19891 case 8:
19892 case 9:
19893 case 10:
19894 case 11:
19895 case 12:
19896 case 13:
19897 case 14:
19898 case 15:
19899 case 16:
19900 case 17:
19901 case 18:
19902 case 19:
19903 case 20:
19904 case 21:
19905 case 22:
19906 case 23:
19907 case 24:
19908 case 34:
19909 case 35:
19910 case 36:
19911 case 37:
19912 case 38:
19913 case 39:
19914 case 40:
19915 case 41:
19916 case 42:
19917 case 43:
19918 case 44:
19919 case 45:
19920 case 46:
19921 case 47:
19922 case 48:
19923 case 49:
19924 case 50:
19925 case 51:
19926 case 52:
19927 case 53:
19928 case 54:
19929 case 55:
19930 {
19931 return 7;
19932 }
19933 case 0:
19934 {
19935 return 39;
19936 }
19937 case 1:
19938 {
19939 return 40;
19940 }
19941 case 4:
19942 {
19943 return 41;
19944 }
19945 case 25:
19946 case 26:
19947 case 27:
19948 case 28:
19949 case 29:
19950 case 30:
19951 case 31:
19952 case 32:
19953 case 33:
19954 {
19955 return 236;
19956 }
19957 default:
19958 {
19959 return -1;
19960 }
19961 }
19962 }
19963 case 236:
19964 {
19965 switch (i)
19966 {
19967 case 2:
19968 case 3:
19969 case 5:
19970 case 6:
19971 case 7:
19972 case 8:
19973 case 9:
19974 case 10:
19975 case 11:
19976 case 12:
19977 case 13:
19978 case 14:
19979 case 15:
19980 case 16:
19981 case 17:
19982 case 18:
19983 case 19:
19984 case 20:
19985 case 21:
19986 case 22:
19987 case 23:
19988 case 24:
19989 case 34:
19990 case 35:
19991 case 36:
19992 case 37:
19993 case 38:
19994 case 39:
19995 case 40:
19996 case 41:
19997 case 42:
19998 case 43:
19999 case 44:
20000 case 45:
20001 case 46:
20002 case 47:
20003 case 48:
20004 case 49:
20005 case 50:
20006 case 51:
20007 case 52:
20008 case 53:
20009 case 54:
20010 case 55:
20011 {
20012 return 7;
20013 }
20014 case 0:
20015 {
20016 return 39;
20017 }
20018 case 1:
20019 {
20020 return 40;
20021 }
20022 case 4:
20023 {
20024 return 41;
20025 }
20026 case 25:
20027 case 26:
20028 case 27:
20029 case 28:
20030 case 29:
20031 case 30:
20032 case 31:
20033 case 32:
20034 case 33:
20035 {
20036 return 237;
20037 }
20038 default:
20039 {
20040 return -1;
20041 }
20042 }
20043 }
20044 case 237:
20045 {
20046 switch (i)
20047 {
20048 case 2:
20049 case 3:
20050 case 5:
20051 case 6:
20052 case 7:
20053 case 8:
20054 case 9:
20055 case 10:
20056 case 11:
20057 case 12:
20058 case 13:
20059 case 14:
20060 case 15:
20061 case 16:
20062 case 17:
20063 case 18:
20064 case 19:
20065 case 20:
20066 case 21:
20067 case 22:
20068 case 23:
20069 case 24:
20070 case 34:
20071 case 35:
20072 case 36:
20073 case 37:
20074 case 38:
20075 case 39:
20076 case 40:
20077 case 41:
20078 case 42:
20079 case 43:
20080 case 44:
20081 case 45:
20082 case 46:
20083 case 47:
20084 case 48:
20085 case 49:
20086 case 50:
20087 case 51:
20088 case 52:
20089 case 53:
20090 case 54:
20091 case 55:
20092 {
20093 return 7;
20094 }
20095 case 0:
20096 {
20097 return 39;
20098 }
20099 case 1:
20100 {
20101 return 40;
20102 }
20103 case 4:
20104 {
20105 return 41;
20106 }
20107 case 25:
20108 case 26:
20109 case 27:
20110 case 28:
20111 case 29:
20112 case 30:
20113 case 31:
20114 case 32:
20115 case 33:
20116 {
20117 return 238;
20118 }
20119 default:
20120 {
20121 return -1;
20122 }
20123 }
20124 }
20125 case 238:
20126 {
20127 switch (i)
20128 {
20129 case 2:
20130 case 3:
20131 case 5:
20132 case 6:
20133 case 7:
20134 case 8:
20135 case 9:
20136 case 10:
20137 case 11:
20138 case 12:
20139 case 13:
20140 case 14:
20141 case 15:
20142 case 16:
20143 case 17:
20144 case 18:
20145 case 19:
20146 case 20:
20147 case 21:
20148 case 22:
20149 case 23:
20150 case 24:
20151 case 34:
20152 case 35:
20153 case 36:
20154 case 37:
20155 case 38:
20156 case 39:
20157 case 40:
20158 case 41:
20159 case 42:
20160 case 43:
20161 case 44:
20162 case 45:
20163 case 46:
20164 case 47:
20165 case 48:
20166 case 49:
20167 case 50:
20168 case 51:
20169 case 52:
20170 case 53:
20171 case 54:
20172 case 55:
20173 {
20174 return 7;
20175 }
20176 case 0:
20177 {
20178 return 39;
20179 }
20180 case 1:
20181 {
20182 return 40;
20183 }
20184 case 4:
20185 {
20186 return 41;
20187 }
20188 case 25:
20189 case 26:
20190 case 27:
20191 case 28:
20192 case 29:
20193 case 30:
20194 case 31:
20195 case 32:
20196 case 33:
20197 {
20198 return 239;
20199 }
20200 default:
20201 {
20202 return -1;
20203 }
20204 }
20205 }
20206 case 239:
20207 {
20208 switch (i)
20209 {
20210 case 2:
20211 case 3:
20212 case 5:
20213 case 6:
20214 case 7:
20215 case 8:
20216 case 9:
20217 case 10:
20218 case 11:
20219 case 12:
20220 case 13:
20221 case 14:
20222 case 15:
20223 case 16:
20224 case 17:
20225 case 18:
20226 case 19:
20227 case 20:
20228 case 21:
20229 case 22:
20230 case 23:
20231 case 24:
20232 case 34:
20233 case 35:
20234 case 36:
20235 case 37:
20236 case 38:
20237 case 39:
20238 case 40:
20239 case 41:
20240 case 42:
20241 case 43:
20242 case 44:
20243 case 45:
20244 case 46:
20245 case 47:
20246 case 48:
20247 case 49:
20248 case 50:
20249 case 51:
20250 case 52:
20251 case 53:
20252 case 54:
20253 case 55:
20254 {
20255 return 7;
20256 }
20257 case 0:
20258 {
20259 return 39;
20260 }
20261 case 1:
20262 {
20263 return 40;
20264 }
20265 case 4:
20266 {
20267 return 41;
20268 }
20269 case 25:
20270 case 26:
20271 case 27:
20272 case 28:
20273 case 29:
20274 case 30:
20275 case 31:
20276 case 32:
20277 case 33:
20278 {
20279 return 240;
20280 }
20281 default:
20282 {
20283 return -1;
20284 }
20285 }
20286 }
20287 case 240:
20288 {
20289 switch (i)
20290 {
20291 case 2:
20292 case 3:
20293 case 5:
20294 case 6:
20295 case 7:
20296 case 8:
20297 case 9:
20298 case 10:
20299 case 11:
20300 case 12:
20301 case 13:
20302 case 14:
20303 case 15:
20304 case 16:
20305 case 17:
20306 case 18:
20307 case 19:
20308 case 20:
20309 case 21:
20310 case 22:
20311 case 23:
20312 case 24:
20313 case 34:
20314 case 35:
20315 case 36:
20316 case 37:
20317 case 38:
20318 case 39:
20319 case 40:
20320 case 41:
20321 case 42:
20322 case 43:
20323 case 44:
20324 case 45:
20325 case 46:
20326 case 47:
20327 case 48:
20328 case 49:
20329 case 50:
20330 case 51:
20331 case 52:
20332 case 53:
20333 case 54:
20334 case 55:
20335 {
20336 return 7;
20337 }
20338 case 0:
20339 {
20340 return 39;
20341 }
20342 case 1:
20343 {
20344 return 40;
20345 }
20346 case 4:
20347 {
20348 return 41;
20349 }
20350 case 25:
20351 case 26:
20352 case 27:
20353 case 28:
20354 case 29:
20355 case 30:
20356 case 31:
20357 case 32:
20358 case 33:
20359 {
20360 return 241;
20361 }
20362 default:
20363 {
20364 return -1;
20365 }
20366 }
20367 }
20368 case 241:
20369 {
20370 switch (i)
20371 {
20372 case 2:
20373 case 3:
20374 case 5:
20375 case 6:
20376 case 7:
20377 case 8:
20378 case 9:
20379 case 10:
20380 case 11:
20381 case 12:
20382 case 13:
20383 case 14:
20384 case 15:
20385 case 16:
20386 case 17:
20387 case 18:
20388 case 19:
20389 case 20:
20390 case 21:
20391 case 22:
20392 case 23:
20393 case 24:
20394 case 34:
20395 case 35:
20396 case 36:
20397 case 37:
20398 case 38:
20399 case 39:
20400 case 40:
20401 case 41:
20402 case 42:
20403 case 43:
20404 case 44:
20405 case 45:
20406 case 46:
20407 case 47:
20408 case 48:
20409 case 49:
20410 case 50:
20411 case 51:
20412 case 52:
20413 case 53:
20414 case 54:
20415 case 55:
20416 {
20417 return 7;
20418 }
20419 case 0:
20420 {
20421 return 39;
20422 }
20423 case 1:
20424 {
20425 return 40;
20426 }
20427 case 4:
20428 {
20429 return 41;
20430 }
20431 case 25:
20432 case 26:
20433 case 27:
20434 case 28:
20435 case 29:
20436 case 30:
20437 case 31:
20438 case 32:
20439 case 33:
20440 {
20441 return 242;
20442 }
20443 default:
20444 {
20445 return -1;
20446 }
20447 }
20448 }
20449 case 242:
20450 {
20451 switch (i)
20452 {
20453 case 0:
20454 {
20455 return 39;
20456 }
20457 case 1:
20458 {
20459 return 40;
20460 }
20461 case 2:
20462 {
20463 return 217;
20464 }
20465 case 3:
20466 case 5:
20467 case 6:
20468 case 7:
20469 case 9:
20470 case 10:
20471 case 11:
20472 case 12:
20473 case 13:
20474 case 14:
20475 case 15:
20476 case 16:
20477 case 17:
20478 case 18:
20479 case 19:
20480 case 20:
20481 case 21:
20482 case 22:
20483 case 23:
20484 case 24:
20485 case 25:
20486 case 26:
20487 case 27:
20488 case 28:
20489 case 29:
20490 case 30:
20491 case 31:
20492 case 32:
20493 case 33:
20494 case 34:
20495 case 35:
20496 case 36:
20497 case 38:
20498 case 39:
20499 case 40:
20500 case 41:
20501 case 42:
20502 case 43:
20503 case 44:
20504 case 45:
20505 case 46:
20506 case 47:
20507 case 48:
20508 case 49:
20509 case 50:
20510 case 51:
20511 case 52:
20512 case 53:
20513 case 54:
20514 case 55:
20515 {
20516 return 218;
20517 }
20518 case 4:
20519 {
20520 return 219;
20521 }
20522 case 8:
20523 {
20524 return 220;
20525 }
20526 case 37:
20527 {
20528 return 243;
20529 }
20530 default:
20531 {
20532 return -1;
20533 }
20534 }
20535 }
20536 case 243:
20537 {
20538 switch (i)
20539 {
20540 case 0:
20541 {
20542 return 39;
20543 }
20544 case 1:
20545 {
20546 return 40;
20547 }
20548 case 2:
20549 {
20550 return 217;
20551 }
20552 case 3:
20553 case 5:
20554 case 6:
20555 case 7:
20556 case 9:
20557 case 10:
20558 case 11:
20559 case 12:
20560 case 13:
20561 case 14:
20562 case 15:
20563 case 16:
20564 case 17:
20565 case 18:
20566 case 19:
20567 case 20:
20568 case 21:
20569 case 22:
20570 case 23:
20571 case 24:
20572 case 25:
20573 case 26:
20574 case 27:
20575 case 28:
20576 case 29:
20577 case 30:
20578 case 31:
20579 case 32:
20580 case 33:
20581 case 34:
20582 case 35:
20583 case 36:
20584 case 37:
20585 case 38:
20586 case 39:
20587 case 40:
20588 case 41:
20589 case 42:
20590 case 43:
20591 case 44:
20592 case 45:
20593 case 46:
20594 case 47:
20595 case 48:
20596 case 49:
20597 case 50:
20598 case 51:
20599 case 52:
20600 case 53:
20601 case 54:
20602 case 55:
20603 {
20604 return 218;
20605 }
20606 case 4:
20607 {
20608 return 219;
20609 }
20610 case 8:
20611 {
20612 return 220;
20613 }
20614 default:
20615 {
20616 return -1;
20617 }
20618 }
20619 }
20620 case 222:
20621 {
20622 switch (i)
20623 {
20624 case 2:
20625 case 3:
20626 case 5:
20627 case 6:
20628 case 7:
20629 case 8:
20630 case 9:
20631 case 10:
20632 case 11:
20633 case 12:
20634 case 13:
20635 case 14:
20636 case 15:
20637 case 16:
20638 case 17:
20639 case 18:
20640 case 19:
20641 case 20:
20642 case 21:
20643 case 22:
20644 case 23:
20645 case 24:
20646 case 34:
20647 case 35:
20648 case 36:
20649 case 37:
20650 case 38:
20651 case 39:
20652 case 40:
20653 case 41:
20654 case 42:
20655 case 43:
20656 case 44:
20657 case 45:
20658 case 46:
20659 case 47:
20660 case 48:
20661 case 49:
20662 case 50:
20663 case 51:
20664 case 52:
20665 case 53:
20666 case 54:
20667 case 55:
20668 {
20669 return 7;
20670 }
20671 case 0:
20672 {
20673 return 39;
20674 }
20675 case 1:
20676 {
20677 return 40;
20678 }
20679 case 4:
20680 {
20681 return 41;
20682 }
20683 case 25:
20684 case 26:
20685 case 27:
20686 case 28:
20687 case 29:
20688 case 30:
20689 case 31:
20690 case 32:
20691 case 33:
20692 {
20693 return 244;
20694 }
20695 default:
20696 {
20697 return -1;
20698 }
20699 }
20700 }
20701 case 244:
20702 {
20703 switch (i)
20704 {
20705 case 2:
20706 case 3:
20707 case 5:
20708 case 6:
20709 case 7:
20710 case 8:
20711 case 9:
20712 case 10:
20713 case 11:
20714 case 12:
20715 case 13:
20716 case 14:
20717 case 15:
20718 case 16:
20719 case 17:
20720 case 18:
20721 case 19:
20722 case 20:
20723 case 21:
20724 case 22:
20725 case 23:
20726 case 24:
20727 case 34:
20728 case 35:
20729 case 36:
20730 case 37:
20731 case 38:
20732 case 39:
20733 case 40:
20734 case 41:
20735 case 42:
20736 case 43:
20737 case 44:
20738 case 45:
20739 case 46:
20740 case 47:
20741 case 48:
20742 case 49:
20743 case 50:
20744 case 51:
20745 case 52:
20746 case 53:
20747 case 54:
20748 case 55:
20749 {
20750 return 7;
20751 }
20752 case 0:
20753 {
20754 return 39;
20755 }
20756 case 1:
20757 {
20758 return 40;
20759 }
20760 case 4:
20761 {
20762 return 41;
20763 }
20764 case 25:
20765 case 26:
20766 case 27:
20767 case 28:
20768 case 29:
20769 case 30:
20770 case 31:
20771 case 32:
20772 case 33:
20773 {
20774 return 245;
20775 }
20776 default:
20777 {
20778 return -1;
20779 }
20780 }
20781 }
20782 case 245:
20783 {
20784 switch (i)
20785 {
20786 case 2:
20787 case 3:
20788 case 5:
20789 case 6:
20790 case 7:
20791 case 8:
20792 case 9:
20793 case 10:
20794 case 11:
20795 case 12:
20796 case 13:
20797 case 14:
20798 case 15:
20799 case 16:
20800 case 17:
20801 case 18:
20802 case 19:
20803 case 20:
20804 case 21:
20805 case 22:
20806 case 23:
20807 case 24:
20808 case 34:
20809 case 35:
20810 case 36:
20811 case 37:
20812 case 38:
20813 case 39:
20814 case 40:
20815 case 41:
20816 case 42:
20817 case 43:
20818 case 44:
20819 case 45:
20820 case 46:
20821 case 47:
20822 case 48:
20823 case 49:
20824 case 50:
20825 case 51:
20826 case 52:
20827 case 53:
20828 case 54:
20829 case 55:
20830 {
20831 return 7;
20832 }
20833 case 0:
20834 {
20835 return 39;
20836 }
20837 case 1:
20838 {
20839 return 40;
20840 }
20841 case 4:
20842 {
20843 return 41;
20844 }
20845 case 25:
20846 case 26:
20847 case 27:
20848 case 28:
20849 case 29:
20850 case 30:
20851 case 31:
20852 case 32:
20853 case 33:
20854 {
20855 return 246;
20856 }
20857 default:
20858 {
20859 return -1;
20860 }
20861 }
20862 }
20863 case 246:
20864 {
20865 switch (i)
20866 {
20867 case 2:
20868 case 3:
20869 case 5:
20870 case 6:
20871 case 7:
20872 case 8:
20873 case 9:
20874 case 10:
20875 case 11:
20876 case 12:
20877 case 13:
20878 case 14:
20879 case 15:
20880 case 16:
20881 case 17:
20882 case 18:
20883 case 19:
20884 case 20:
20885 case 21:
20886 case 22:
20887 case 23:
20888 case 24:
20889 case 34:
20890 case 35:
20891 case 36:
20892 case 37:
20893 case 38:
20894 case 39:
20895 case 40:
20896 case 41:
20897 case 42:
20898 case 43:
20899 case 44:
20900 case 45:
20901 case 46:
20902 case 47:
20903 case 48:
20904 case 49:
20905 case 50:
20906 case 51:
20907 case 52:
20908 case 53:
20909 case 54:
20910 case 55:
20911 {
20912 return 7;
20913 }
20914 case 0:
20915 {
20916 return 39;
20917 }
20918 case 1:
20919 {
20920 return 40;
20921 }
20922 case 4:
20923 {
20924 return 41;
20925 }
20926 case 25:
20927 case 26:
20928 case 27:
20929 case 28:
20930 case 29:
20931 case 30:
20932 case 31:
20933 case 32:
20934 case 33:
20935 {
20936 return 247;
20937 }
20938 default:
20939 {
20940 return -1;
20941 }
20942 }
20943 }
20944 case 247:
20945 {
20946 switch (i)
20947 {
20948 case 0:
20949 {
20950 return 39;
20951 }
20952 case 1:
20953 {
20954 return 40;
20955 }
20956 case 2:
20957 {
20958 return 217;
20959 }
20960 case 3:
20961 case 5:
20962 case 6:
20963 case 7:
20964 case 9:
20965 case 10:
20966 case 11:
20967 case 12:
20968 case 13:
20969 case 14:
20970 case 15:
20971 case 16:
20972 case 17:
20973 case 18:
20974 case 19:
20975 case 20:
20976 case 21:
20977 case 22:
20978 case 23:
20979 case 24:
20980 case 25:
20981 case 26:
20982 case 27:
20983 case 28:
20984 case 29:
20985 case 30:
20986 case 31:
20987 case 32:
20988 case 33:
20989 case 34:
20990 case 35:
20991 case 36:
20992 case 38:
20993 case 39:
20994 case 40:
20995 case 41:
20996 case 42:
20997 case 43:
20998 case 44:
20999 case 45:
21000 case 46:
21001 case 47:
21002 case 48:
21003 case 49:
21004 case 50:
21005 case 51:
21006 case 52:
21007 case 53:
21008 case 54:
21009 case 55:
21010 {
21011 return 218;
21012 }
21013 case 4:
21014 {
21015 return 219;
21016 }
21017 case 8:
21018 {
21019 return 220;
21020 }
21021 case 37:
21022 {
21023 return 243;
21024 }
21025 default:
21026 {
21027 return -1;
21028 }
21029 }
21030 }
21031 case 221:
21032 {
21033 switch (i)
21034 {
21035 case 0:
21036 {
21037 return 39;
21038 }
21039 case 1:
21040 {
21041 return 40;
21042 }
21043 case 2:
21044 {
21045 return 217;
21046 }
21047 case 3:
21048 case 5:
21049 case 6:
21050 case 7:
21051 case 9:
21052 case 10:
21053 case 11:
21054 case 12:
21055 case 13:
21056 case 14:
21057 case 15:
21058 case 16:
21059 case 17:
21060 case 18:
21061 case 19:
21062 case 20:
21063 case 21:
21064 case 22:
21065 case 23:
21066 case 24:
21067 case 25:
21068 case 26:
21069 case 27:
21070 case 28:
21071 case 29:
21072 case 30:
21073 case 31:
21074 case 32:
21075 case 33:
21076 case 34:
21077 case 35:
21078 case 36:
21079 case 38:
21080 case 39:
21081 case 40:
21082 case 41:
21083 case 42:
21084 case 43:
21085 case 44:
21086 case 45:
21087 case 46:
21088 case 47:
21089 case 48:
21090 case 49:
21091 case 50:
21092 case 51:
21093 case 52:
21094 case 53:
21095 case 54:
21096 case 55:
21097 {
21098 return 218;
21099 }
21100 case 4:
21101 {
21102 return 219;
21103 }
21104 case 8:
21105 {
21106 return 220;
21107 }
21108 case 37:
21109 {
21110 return 229;
21111 }
21112 default:
21113 {
21114 return -1;
21115 }
21116 }
21117 }
21118 case 219:
21119 {
21120 switch (i)
21121 {
21122 case 0:
21123 {
21124 return 39;
21125 }
21126 case 1:
21127 {
21128 return 40;
21129 }
21130 case 4:
21131 {
21132 return 219;
21133 }
21134 case 2:
21135 {
21136 return 248;
21137 }
21138 case 3:
21139 {
21140 return 249;
21141 }
21142 case 5:
21143 case 6:
21144 case 7:
21145 case 9:
21146 case 10:
21147 case 11:
21148 case 12:
21149 case 13:
21150 case 14:
21151 case 15:
21152 case 16:
21153 case 17:
21154 case 18:
21155 case 19:
21156 case 20:
21157 case 21:
21158 case 22:
21159 case 23:
21160 case 24:
21161 case 25:
21162 case 26:
21163 case 27:
21164 case 28:
21165 case 29:
21166 case 30:
21167 case 31:
21168 case 32:
21169 case 33:
21170 case 34:
21171 case 35:
21172 case 36:
21173 case 37:
21174 case 38:
21175 case 39:
21176 case 40:
21177 case 41:
21178 case 42:
21179 case 43:
21180 case 44:
21181 case 45:
21182 case 46:
21183 case 47:
21184 case 48:
21185 case 49:
21186 case 50:
21187 case 51:
21188 case 52:
21189 case 53:
21190 case 54:
21191 case 55:
21192 {
21193 return 250;
21194 }
21195 case 8:
21196 {
21197 return 251;
21198 }
21199 default:
21200 {
21201 return -1;
21202 }
21203 }
21204 }
21205 case 251:
21206 {
21207 switch (i)
21208 {
21209 case 3:
21210 case 5:
21211 case 6:
21212 case 7:
21213 case 11:
21214 case 12:
21215 case 13:
21216 case 14:
21217 case 17:
21218 case 23:
21219 case 24:
21220 case 25:
21221 case 26:
21222 case 28:
21223 case 32:
21224 case 33:
21225 case 34:
21226 case 35:
21227 case 36:
21228 case 37:
21229 case 38:
21230 case 39:
21231 case 40:
21232 case 41:
21233 case 42:
21234 case 43:
21235 case 44:
21236 case 45:
21237 case 46:
21238 case 47:
21239 case 48:
21240 case 49:
21241 case 50:
21242 case 51:
21243 case 52:
21244 case 53:
21245 case 54:
21246 case 55:
21247 {
21248 return 7;
21249 }
21250 case 0:
21251 {
21252 return 39;
21253 }
21254 case 1:
21255 {
21256 return 40;
21257 }
21258 case 4:
21259 {
21260 return 41;
21261 }
21262 case 2:
21263 case 8:
21264 case 9:
21265 case 10:
21266 case 19:
21267 case 20:
21268 case 21:
21269 case 22:
21270 case 29:
21271 case 30:
21272 case 31:
21273 {
21274 return 221;
21275 }
21276 case 15:
21277 {
21278 return 222;
21279 }
21280 case 16:
21281 {
21282 return 223;
21283 }
21284 case 18:
21285 {
21286 return 224;
21287 }
21288 case 27:
21289 {
21290 return 225;
21291 }
21292 default:
21293 {
21294 return -1;
21295 }
21296 }
21297 }
21298 case 250:
21299 {
21300 switch (i)
21301 {
21302 case 0:
21303 {
21304 return 39;
21305 }
21306 case 1:
21307 {
21308 return 40;
21309 }
21310 case 2:
21311 {
21312 return 217;
21313 }
21314 case 3:
21315 case 5:
21316 case 6:
21317 case 7:
21318 case 9:
21319 case 10:
21320 case 11:
21321 case 12:
21322 case 13:
21323 case 14:
21324 case 15:
21325 case 16:
21326 case 17:
21327 case 18:
21328 case 19:
21329 case 20:
21330 case 21:
21331 case 22:
21332 case 23:
21333 case 24:
21334 case 25:
21335 case 26:
21336 case 27:
21337 case 28:
21338 case 29:
21339 case 30:
21340 case 31:
21341 case 32:
21342 case 33:
21343 case 34:
21344 case 35:
21345 case 36:
21346 case 37:
21347 case 38:
21348 case 39:
21349 case 40:
21350 case 41:
21351 case 42:
21352 case 43:
21353 case 44:
21354 case 45:
21355 case 46:
21356 case 47:
21357 case 48:
21358 case 49:
21359 case 50:
21360 case 51:
21361 case 52:
21362 case 53:
21363 case 54:
21364 case 55:
21365 {
21366 return 218;
21367 }
21368 case 4:
21369 {
21370 return 219;
21371 }
21372 case 8:
21373 {
21374 return 220;
21375 }
21376 default:
21377 {
21378 return -1;
21379 }
21380 }
21381 }
21382 case 249:
21383 {
21384 Lexeme prevMatch = token.match;
21385 token.match = lexeme;
21386 int tokenId = GetTokenId(4);
21387 if (tokenId == CONTINUE_TOKEN)
21388 {
21389 token.id = tokenId;
21390 return -1;
21391 }
21392 else if (tokenId != INVALID_TOKEN)
21393 {
21394 token.id = tokenId;
21395 }
21396 else
21397 {
21398 token.match = prevMatch;
21399 }
21400 switch (i)
21401 {
21402 case 0:
21403 {
21404 return 39;
21405 }
21406 case 1:
21407 {
21408 return 40;
21409 }
21410 case 2:
21411 {
21412 return 217;
21413 }
21414 case 3:
21415 case 5:
21416 case 6:
21417 case 7:
21418 case 9:
21419 case 10:
21420 case 11:
21421 case 12:
21422 case 13:
21423 case 14:
21424 case 15:
21425 case 16:
21426 case 17:
21427 case 18:
21428 case 19:
21429 case 20:
21430 case 21:
21431 case 22:
21432 case 23:
21433 case 24:
21434 case 25:
21435 case 26:
21436 case 27:
21437 case 28:
21438 case 29:
21439 case 30:
21440 case 31:
21441 case 32:
21442 case 33:
21443 case 34:
21444 case 35:
21445 case 36:
21446 case 38:
21447 case 39:
21448 case 40:
21449 case 41:
21450 case 42:
21451 case 43:
21452 case 44:
21453 case 45:
21454 case 46:
21455 case 47:
21456 case 48:
21457 case 49:
21458 case 50:
21459 case 51:
21460 case 52:
21461 case 53:
21462 case 54:
21463 case 55:
21464 {
21465 return 218;
21466 }
21467 case 4:
21468 {
21469 return 219;
21470 }
21471 case 8:
21472 {
21473 return 220;
21474 }
21475 case 37:
21476 {
21477 return 252;
21478 }
21479 default:
21480 {
21481 return -1;
21482 }
21483 }
21484 }
21485 case 252:
21486 {
21487 Lexeme prevMatch = token.match;
21488 token.match = lexeme;
21489 int tokenId = GetTokenId(4);
21490 if (tokenId == CONTINUE_TOKEN)
21491 {
21492 token.id = tokenId;
21493 return -1;
21494 }
21495 else if (tokenId != INVALID_TOKEN)
21496 {
21497 token.id = tokenId;
21498 }
21499 else
21500 {
21501 token.match = prevMatch;
21502 }
21503 switch (i)
21504 {
21505 case 0:
21506 {
21507 return 39;
21508 }
21509 case 1:
21510 {
21511 return 40;
21512 }
21513 case 2:
21514 {
21515 return 217;
21516 }
21517 case 3:
21518 case 5:
21519 case 6:
21520 case 7:
21521 case 9:
21522 case 10:
21523 case 11:
21524 case 12:
21525 case 13:
21526 case 14:
21527 case 15:
21528 case 16:
21529 case 17:
21530 case 18:
21531 case 19:
21532 case 20:
21533 case 21:
21534 case 22:
21535 case 23:
21536 case 24:
21537 case 25:
21538 case 26:
21539 case 27:
21540 case 28:
21541 case 29:
21542 case 30:
21543 case 31:
21544 case 32:
21545 case 33:
21546 case 34:
21547 case 35:
21548 case 36:
21549 case 37:
21550 case 38:
21551 case 39:
21552 case 40:
21553 case 41:
21554 case 42:
21555 case 43:
21556 case 44:
21557 case 45:
21558 case 46:
21559 case 47:
21560 case 48:
21561 case 49:
21562 case 50:
21563 case 51:
21564 case 52:
21565 case 53:
21566 case 54:
21567 case 55:
21568 {
21569 return 218;
21570 }
21571 case 4:
21572 {
21573 return 219;
21574 }
21575 case 8:
21576 {
21577 return 220;
21578 }
21579 default:
21580 {
21581 return -1;
21582 }
21583 }
21584 }
21585 case 248:
21586 {
21587 Lexeme prevMatch = token.match;
21588 token.match = lexeme;
21589 int tokenId = GetTokenId(7);
21590 if (tokenId == CONTINUE_TOKEN)
21591 {
21592 token.id = tokenId;
21593 return -1;
21594 }
21595 else if (tokenId != INVALID_TOKEN)
21596 {
21597 token.id = tokenId;
21598 }
21599 else
21600 {
21601 token.match = prevMatch;
21602 }
21603 switch (i)
21604 {
21605 case 2:
21606 case 3:
21607 case 5:
21608 case 6:
21609 case 7:
21610 case 8:
21611 case 9:
21612 case 10:
21613 case 11:
21614 case 12:
21615 case 13:
21616 case 14:
21617 case 15:
21618 case 16:
21619 case 17:
21620 case 18:
21621 case 19:
21622 case 20:
21623 case 21:
21624 case 22:
21625 case 23:
21626 case 24:
21627 case 25:
21628 case 26:
21629 case 27:
21630 case 28:
21631 case 29:
21632 case 30:
21633 case 31:
21634 case 32:
21635 case 33:
21636 case 34:
21637 case 35:
21638 case 36:
21639 case 38:
21640 case 39:
21641 case 40:
21642 case 41:
21643 case 42:
21644 case 43:
21645 case 44:
21646 case 45:
21647 case 46:
21648 case 47:
21649 case 48:
21650 case 49:
21651 case 50:
21652 case 51:
21653 case 52:
21654 case 53:
21655 case 54:
21656 case 55:
21657 {
21658 return 7;
21659 }
21660 case 0:
21661 {
21662 return 39;
21663 }
21664 case 1:
21665 {
21666 return 40;
21667 }
21668 case 4:
21669 {
21670 return 41;
21671 }
21672 case 37:
21673 {
21674 return 90;
21675 }
21676 default:
21677 {
21678 return -1;
21679 }
21680 }
21681 }
21682 case 218:
21683 {
21684 switch (i)
21685 {
21686 case 0:
21687 {
21688 return 39;
21689 }
21690 case 1:
21691 {
21692 return 40;
21693 }
21694 case 2:
21695 {
21696 return 217;
21697 }
21698 case 3:
21699 case 5:
21700 case 6:
21701 case 7:
21702 case 9:
21703 case 10:
21704 case 11:
21705 case 12:
21706 case 13:
21707 case 14:
21708 case 15:
21709 case 16:
21710 case 17:
21711 case 18:
21712 case 19:
21713 case 20:
21714 case 21:
21715 case 22:
21716 case 23:
21717 case 24:
21718 case 25:
21719 case 26:
21720 case 27:
21721 case 28:
21722 case 29:
21723 case 30:
21724 case 31:
21725 case 32:
21726 case 33:
21727 case 34:
21728 case 35:
21729 case 36:
21730 case 37:
21731 case 38:
21732 case 39:
21733 case 40:
21734 case 41:
21735 case 42:
21736 case 43:
21737 case 44:
21738 case 45:
21739 case 46:
21740 case 47:
21741 case 48:
21742 case 49:
21743 case 50:
21744 case 51:
21745 case 52:
21746 case 53:
21747 case 54:
21748 case 55:
21749 {
21750 return 218;
21751 }
21752 case 4:
21753 {
21754 return 219;
21755 }
21756 case 8:
21757 {
21758 return 220;
21759 }
21760 default:
21761 {
21762 return -1;
21763 }
21764 }
21765 }
21766 case 217:
21767 {
21768 Lexeme prevMatch = token.match;
21769 token.match = lexeme;
21770 int tokenId = GetTokenId(7);
21771 if (tokenId == CONTINUE_TOKEN)
21772 {
21773 token.id = tokenId;
21774 return -1;
21775 }
21776 else if (tokenId != INVALID_TOKEN)
21777 {
21778 token.id = tokenId;
21779 }
21780 else
21781 {
21782 token.match = prevMatch;
21783 }
21784 switch (i)
21785 {
21786 case 2:
21787 case 3:
21788 case 5:
21789 case 6:
21790 case 7:
21791 case 8:
21792 case 9:
21793 case 10:
21794 case 11:
21795 case 12:
21796 case 13:
21797 case 14:
21798 case 15:
21799 case 16:
21800 case 17:
21801 case 18:
21802 case 19:
21803 case 20:
21804 case 21:
21805 case 22:
21806 case 23:
21807 case 24:
21808 case 25:
21809 case 26:
21810 case 27:
21811 case 28:
21812 case 29:
21813 case 30:
21814 case 31:
21815 case 32:
21816 case 33:
21817 case 34:
21818 case 35:
21819 case 36:
21820 case 38:
21821 case 39:
21822 case 40:
21823 case 41:
21824 case 42:
21825 case 43:
21826 case 44:
21827 case 45:
21828 case 46:
21829 case 47:
21830 case 48:
21831 case 49:
21832 case 50:
21833 case 51:
21834 case 52:
21835 case 53:
21836 case 54:
21837 case 55:
21838 {
21839 return 7;
21840 }
21841 case 0:
21842 {
21843 return 39;
21844 }
21845 case 1:
21846 {
21847 return 40;
21848 }
21849 case 4:
21850 {
21851 return 41;
21852 }
21853 case 37:
21854 {
21855 return 90;
21856 }
21857 default:
21858 {
21859 return -1;
21860 }
21861 }
21862 }
21863 case 2:
21864 {
21865 Lexeme prevMatch = token.match;
21866 token.match = lexeme;
21867 int tokenId = GetTokenId(1);
21868 if (tokenId == CONTINUE_TOKEN)
21869 {
21870 token.id = tokenId;
21871 return -1;
21872 }
21873 else if (tokenId != INVALID_TOKEN)
21874 {
21875 token.id = tokenId;
21876 }
21877 else
21878 {
21879 token.match = prevMatch;
21880 }
21881 switch (i)
21882 {
21883 case 37:
21884 {
21885 return 80;
21886 }
21887 default:
21888 {
21889 return -1;
21890 }
21891 }
21892 }
21893 case 1:
21894 {
21895 Lexeme prevMatch = token.match;
21896 token.match = lexeme;
21897 int tokenId = GetTokenId(1);
21898 if (tokenId == CONTINUE_TOKEN)
21899 {
21900 token.id = tokenId;
21901 return -1;
21902 }
21903 else if (tokenId != INVALID_TOKEN)
21904 {
21905 token.id = tokenId;
21906 }
21907 else
21908 {
21909 token.match = prevMatch;
21910 }
21911 switch (i)
21912 {
21913 case 1:
21914 {
21915 return 79;
21916 }
21917 case 37:
21918 {
21919 return 81;
21920 }
21921 default:
21922 {
21923 return -1;
21924 }
21925 }
21926 }
21927 }
21928 return -1;
21929 }
21930
21931 int CppTokenLexer::GetTokenId(int statementIndex)
21932 {
21933 switch (statementIndex)
21934 {
21935 case 0:
21936 {
21937 Retract();
21938 return WS;
21939 break;
21940 }
21941 case 1:
21942 {
21943 Retract();
21944 break;
21945 }
21946 case 2:
21947 {
21948 Retract();
21949 return LINECOMMENT;
21950 break;
21951 }
21952 case 3:
21953 {
21954 Retract();
21955 return BLOCKCOMMENT;
21956 break;
21957 }
21958 case 4:
21959 {
21960 if (!inBlockComment) return INVALID_TOKEN;
21961 Retract();
21962 return BLOCKCOMMENTLINE;
21963 break;
21964 }
21965 case 5:
21966 {
21967 Retract();
21968 if (GetKeywordToken(token.match) != INVALID_TOKEN) return KEYWORD;
21969 else return ID;
21970 break;
21971 }
21972 case 6:
21973 {
21974 Retract();
21975 return CHARLIT;
21976 break;
21977 }
21978 case 7:
21979 {
21980 Retract();
21981 return STRINGLIT;
21982 break;
21983 }
21984 case 8:
21985 {
21986 Retract();
21987 return NUMBER;
21988 break;
21989 }
21990 case 9:
21991 {
21992 Retract();
21993 return PP;
21994 break;
21995 }
21996 case 10:
21997 {
21998 Retract();
21999 return OTHER;
22000 break;
22001 }
22002 case 11:
22003 {
22004 Retract();
22005 return OTHER;
22006 break;
22007 }
22008 case 12:
22009 {
22010 Retract();
22011 return OTHER;
22012 break;
22013 }
22014 case 13:
22015 {
22016 Retract();
22017 return OTHER;
22018 break;
22019 }
22020 case 14:
22021 {
22022 Retract();
22023 return OTHER;
22024 break;
22025 }
22026 case 15:
22027 {
22028 Retract();
22029 return OTHER;
22030 break;
22031 }
22032 case 16:
22033 {
22034 Retract();
22035 return OTHER;
22036 break;
22037 }
22038 case 17:
22039 {
22040 Retract();
22041 return OTHER;
22042 break;
22043 }
22044 case 18:
22045 {
22046 Retract();
22047 return OTHER;
22048 break;
22049 }
22050 case 19:
22051 {
22052 Retract();
22053 return OTHER;
22054 break;
22055 }
22056 case 20:
22057 {
22058 Retract();
22059 return OTHER;
22060 break;
22061 }
22062 case 21:
22063 {
22064 Retract();
22065 return OTHER;
22066 break;
22067 }
22068 case 22:
22069 {
22070 Retract();
22071 return OTHER;
22072 break;
22073 }
22074 case 23:
22075 {
22076 Retract();
22077 return OTHER;
22078 break;
22079 }
22080 case 24:
22081 {
22082 Retract();
22083 return OTHER;
22084 break;
22085 }
22086 case 25:
22087 {
22088 Retract();
22089 return OTHER;
22090 break;
22091 }
22092 case 26:
22093 {
22094 Retract();
22095 return OTHER;
22096 break;
22097 }
22098 case 27:
22099 {
22100 Retract();
22101 return OTHER;
22102 break;
22103 }
22104 case 28:
22105 {
22106 Retract();
22107 return OTHER;
22108 break;
22109 }
22110 case 29:
22111 {
22112 Retract();
22113 return OTHER;
22114 break;
22115 }
22116 case 30:
22117 {
22118 Retract();
22119 return OTHER;
22120 break;
22121 }
22122 case 31:
22123 {
22124 Retract();
22125 return OTHER;
22126 break;
22127 }
22128 case 32:
22129 {
22130 Retract();
22131 return OTHER;
22132 break;
22133 }
22134 case 33:
22135 {
22136 Retract();
22137 return OTHER;
22138 break;
22139 }
22140 case 34:
22141 {
22142 Retract();
22143 return OTHER;
22144 break;
22145 }
22146 case 35:
22147 {
22148 Retract();
22149 return OTHER;
22150 break;
22151 }
22152 case 36:
22153 {
22154 Retract();
22155 return OTHER;
22156 break;
22157 }
22158 case 37:
22159 {
22160 Retract();
22161 return OTHER;
22162 break;
22163 }
22164 case 38:
22165 {
22166 Retract();
22167 return OTHER;
22168 break;
22169 }
22170 case 39:
22171 {
22172 Retract();
22173 return OTHER;
22174 break;
22175 }
22176 case 40:
22177 {
22178 Retract();
22179 return OTHER;
22180 break;
22181 }
22182 case 41:
22183 {
22184 Retract();
22185 return OTHER;
22186 break;
22187 }
22188 case 42:
22189 {
22190 Retract();
22191 return OTHER;
22192 break;
22193 }
22194 case 43:
22195 {
22196 Retract();
22197 return OTHER;
22198 break;
22199 }
22200 case 44:
22201 {
22202 Retract();
22203 return OTHER;
22204 break;
22205 }
22206 case 45:
22207 {
22208 Retract();
22209 return OTHER;
22210 break;
22211 }
22212 case 46:
22213 {
22214 Retract();
22215 return OTHER;
22216 break;
22217 }
22218 case 47:
22219 {
22220 Retract();
22221 return OTHER;
22222 break;
22223 }
22224 case 48:
22225 {
22226 Retract();
22227 return OTHER;
22228 break;
22229 }
22230 case 49:
22231 {
22232 Retract();
22233 return OTHER;
22234 break;
22235 }
22236 case 50:
22237 {
22238 Retract();
22239 return OTHER;
22240 break;
22241 }
22242 case 51:
22243 {
22244 Retract();
22245 return OTHER;
22246 break;
22247 }
22248 case 52:
22249 {
22250 Retract();
22251 return OTHER;
22252 break;
22253 }
22254 case 53:
22255 {
22256 Retract();
22257 return OTHER;
22258 break;
22259 }
22260 case 54:
22261 {
22262 Retract();
22263 return OTHER;
22264 break;
22265 }
22266 case 55:
22267 {
22268 Retract();
22269 return OTHER;
22270 break;
22271 }
22272 case 56:
22273 {
22274 Retract();
22275 return OTHER;
22276 break;
22277 }
22278 case 57:
22279 {
22280 Retract();
22281 return OTHER;
22282 break;
22283 }
22284 case 58:
22285 {
22286 Retract();
22287 return OTHER;
22288 break;
22289 }
22290 case 59:
22291 {
22292 Retract();
22293 return OTHER;
22294 break;
22295 }
22296 }
22297 return CONTINUE_TOKEN;
22298 }