dparsergen.generator.grammarebnf

1 // Generated with DParserGen.
2 module dparsergen.generator.grammarebnf_lexer;
3 import dparsergen.core.grammarinfo;
4 import dparsergen.core.parseexception;
5 import std.conv;
6 import std.string;
7 import std.typecons;
8 
9 enum SymbolID startTokenID = 0;
10 static assert(allNonterminalTokens.length < SymbolID.max - startTokenID);
11 enum SymbolID endTokenID = startTokenID + allNonterminalTokens.length;
12 
13 SymbolID getTokenID(string tok)
14 {
15     foreach (i; 0 .. allNonterminalTokens.length)
16         if (allNonterminalTokens[i].name == tok)
17             return cast(SymbolID)(startTokenID + i);
18     return SymbolID.max;
19 }
20 
21 struct Lexer(Location, bool includeIgnoredTokens = false)
22 {
23     alias LocationDiff = typeof(Location.init - Location.init);
24     string input;
25     this(string input, Location startLocation = Location.init)
26     {
27         this.input = input;
28         this.front.currentLocation = startLocation;
29         popFront;
30     }
31 
32     enum tokenID(string tok) = getTokenID(tok);
33     string tokenName(size_t id)
34     {
35         return allNonterminalTokens[id - startTokenID].name;
36     }
37 
38     static struct Front
39     {
40         string content;
41         SymbolID symbol;
42         Location currentLocation;
43         static if (includeIgnoredTokens)
44             bool isIgnoreToken;
45 
46         Location currentTokenEnd()
47         {
48             return currentLocation + LocationDiff.fromStr(content);
49         }
50     }
51 
52     Front front;
53     bool empty;
54 
55     void popFront()
56     {
57         input = input[front.content.length .. $];
58         front.currentLocation = front.currentLocation + LocationDiff.fromStr(front.content);
59 
60         popFrontImpl();
61     }
62 
63     void popFrontImpl()
64     {
65         size_t foundLength;
66         SymbolID foundSymbol = SymbolID.max;
67         bool foundIsIgnore;
68 
69         string inputCopy = input;
70 
71         size_t storedStart = size_t.max;
72         string storedString;
73 
74         goto start;
75 
76     state0:
77         // (Identifier) (StringLiteral) (CharacterSetLiteral) (IntegerLiteral) (";") ("=") ("fragment") ("token") ("(") (")") (",") ("...") ("option") ("import") ("match") ("@") (":") ("{") ("}") ("?") ("!") ("<") (">") ("*") (">>") ("<<") ("-") ("anytoken") ("|") ("^") ("+") ("t(") (Space) (LineComment) (BlockComment) (NestingBlockComment)
78         // path:
79     start:
80         {
81             if (inputCopy.length == 0)
82             {
83                 if (input.ptr == inputCopy.ptr)
84                     goto lexerend;
85                 else if (foundSymbol != SymbolID.max)
86                     goto lexerend;
87                 else
88                     throw lexerException("EOF", "[\\t-\\n\\r -\\\"(-\\[\\^-_a-}]", inputCopy.ptr - input.ptr);
89             }
90             char currentChar = inputCopy[0];
91             if (currentChar < 0x80)
92             {
93                 if (currentChar == '!')
94                 {
95                     inputCopy = inputCopy[1 .. $];
96                     goto state97;
97                 }
98                 else if (currentChar == '\"')
99                 {
100                     inputCopy = inputCopy[1 .. $];
101                     goto state49;
102                 }
103                 else if (currentChar == '(')
104                 {
105                     inputCopy = inputCopy[1 .. $];
106                     goto state86;
107                 }
108                 else if (currentChar == ')')
109                 {
110                     inputCopy = inputCopy[1 .. $];
111                     goto state87;
112                 }
113                 else if (currentChar == '*')
114                 {
115                     inputCopy = inputCopy[1 .. $];
116                     goto state102;
117                 }
118                 else if (currentChar == '+')
119                 {
120                     inputCopy = inputCopy[1 .. $];
121                     goto state106;
122                 }
123                 else if (currentChar == ',')
124                 {
125                     inputCopy = inputCopy[1 .. $];
126                     goto state88;
127                 }
128                 else if (currentChar == '-')
129                 {
130                     inputCopy = inputCopy[1 .. $];
131                     goto state103;
132                 }
133                 else if (currentChar == '.')
134                 {
135                     inputCopy = inputCopy[1 .. $];
136                     goto state89;
137                 }
138                 else if (currentChar == '/')
139                 {
140                     inputCopy = inputCopy[1 .. $];
141                     goto state2;
142                 }
143                 else if (currentChar == '0')
144                 {
145                     inputCopy = inputCopy[1 .. $];
146                     goto state83;
147                 }
148                 else if (currentChar == ':')
149                 {
150                     inputCopy = inputCopy[1 .. $];
151                     goto state93;
152                 }
153                 else if (currentChar == ';')
154                 {
155                     inputCopy = inputCopy[1 .. $];
156                     goto state84;
157                 }
158                 else if (currentChar == '<')
159                 {
160                     inputCopy = inputCopy[1 .. $];
161                     goto state98;
162                 }
163                 else if (currentChar == '=')
164                 {
165                     inputCopy = inputCopy[1 .. $];
166                     goto state85;
167                 }
168                 else if (currentChar == '>')
169                 {
170                     inputCopy = inputCopy[1 .. $];
171                     goto state100;
172                 }
173                 else if (currentChar == '?')
174                 {
175                     inputCopy = inputCopy[1 .. $];
176                     goto state96;
177                 }
178                 else if (currentChar == '@')
179                 {
180                     inputCopy = inputCopy[1 .. $];
181                     goto state92;
182                 }
183                 else if (currentChar == '[')
184                 {
185                     inputCopy = inputCopy[1 .. $];
186                     goto state60;
187                 }
188                 else if (currentChar == '^')
189                 {
190                     inputCopy = inputCopy[1 .. $];
191                     goto state105;
192                 }
193                 else if (currentChar == 'a')
194                 {
195                     inputCopy = inputCopy[1 .. $];
196                     goto state18;
197                 }
198                 else if (currentChar == 'f')
199                 {
200                     inputCopy = inputCopy[1 .. $];
201                     goto state9;
202                 }
203                 else if (currentChar == 'i')
204                 {
205                     inputCopy = inputCopy[1 .. $];
206                     goto state43;
207                 }
208                 else if (currentChar == 'm')
209                 {
210                     inputCopy = inputCopy[1 .. $];
211                     goto state26;
212                 }
213                 else if (currentChar == 'o')
214                 {
215                     inputCopy = inputCopy[1 .. $];
216                     goto state37;
217                 }
218                 else if (currentChar == 't')
219                 {
220                     inputCopy = inputCopy[1 .. $];
221                     goto state31;
222                 }
223                 else if (currentChar == '{')
224                 {
225                     inputCopy = inputCopy[1 .. $];
226                     goto state94;
227                 }
228                 else if (currentChar == '|')
229                 {
230                     inputCopy = inputCopy[1 .. $];
231                     goto state104;
232                 }
233                 else if (currentChar == '}')
234                 {
235                     inputCopy = inputCopy[1 .. $];
236                     goto state95;
237                 }
238                 else if ((currentChar >= '1' && currentChar <= '9'))
239                 {
240                     inputCopy = inputCopy[1 .. $];
241                     goto state82;
242                 }
243                 else if ((currentChar >= '\t' && currentChar <= '\n') || currentChar == '\r' || currentChar == ' ')
244                 {
245                     inputCopy = inputCopy[1 .. $];
246                     goto state1;
247                 }
248                 else if ((currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'b' && currentChar <= 'z'))
249                 {
250                     inputCopy = inputCopy[1 .. $];
251                     goto state17;
252                 }
253                 else
254                 {
255                     if (foundSymbol != SymbolID.max)
256                         goto lexerend;
257                     else
258                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[\\t-\\n\\r -\\\"(-\\[\\^-_a-}]", inputCopy.ptr - input.ptr);
259                 }
260             }
261             else
262             {
263                 string inputCopyNext = inputCopy;
264                 import std.utf;
265 
266                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
267 
268                 {
269                     if (foundSymbol != SymbolID.max)
270                         goto lexerend;
271                     else
272                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[\\t-\\n\\r -\\\"(-\\[\\^-_a-}]", inputCopy.ptr - input.ptr);
273                 }
274             }
275         }
276 
277     state1:
278         // Space
279         // path: [\t-\n\r ]
280         {
281             if (inputCopy.length == 0)
282                 goto endstate1;
283             char currentChar = inputCopy[0];
284             if (currentChar < 0x80)
285             {
286                 if ((currentChar >= '\t' && currentChar <= '\n') || currentChar == '\r' || currentChar == ' ')
287                 {
288                     inputCopy = inputCopy[1 .. $];
289                     goto state1;
290                 }
291                 else
292                 {
293                     goto endstate1;
294                 }
295             }
296             else
297             {
298                 string inputCopyNext = inputCopy;
299                 import std.utf;
300 
301                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
302 
303                 {
304                     goto endstate1;
305                 }
306             }
307         }
308         endstate1:
309         {
310             assert(inputCopy.ptr >= input.ptr);
311             foundSymbol = tokenID!"Space";
312             foundLength = inputCopy.ptr - input.ptr;
313             foundIsIgnore = true;
314             goto lexerend;
315         }
316 
317     state2:
318         // (LineComment) (BlockComment) (NestingBlockComment)
319         // path: [/]
320         {
321             if (inputCopy.length == 0)
322             {
323                 if (input.ptr == inputCopy.ptr)
324                     goto lexerend;
325                 else if (foundSymbol != SymbolID.max)
326                     goto lexerend;
327                 else
328                     throw lexerException("EOF", "[*-+/]", inputCopy.ptr - input.ptr);
329             }
330             char currentChar = inputCopy[0];
331             if (currentChar < 0x80)
332             {
333                 if (currentChar == '*')
334                 {
335                     inputCopy = inputCopy[1 .. $];
336                     goto state4;
337                 }
338                 else if (currentChar == '+')
339                 {
340                     inputCopy = inputCopy[1 .. $];
341                     goto state7;
342                 }
343                 else if (currentChar == '/')
344                 {
345                     inputCopy = inputCopy[1 .. $];
346                     goto state3;
347                 }
348                 else
349                 {
350                     if (foundSymbol != SymbolID.max)
351                         goto lexerend;
352                     else
353                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[*-+/]", inputCopy.ptr - input.ptr);
354                 }
355             }
356             else
357             {
358                 string inputCopyNext = inputCopy;
359                 import std.utf;
360 
361                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
362 
363                 {
364                     if (foundSymbol != SymbolID.max)
365                         goto lexerend;
366                     else
367                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[*-+/]", inputCopy.ptr - input.ptr);
368                 }
369             }
370         }
371 
372     state3:
373         // LineComment
374         // path: [/] [/]
375         {
376             if (inputCopy.length == 0)
377                 goto endstate3;
378             char currentChar = inputCopy[0];
379             if (currentChar < 0x80)
380             {
381                 if (currentChar == '\n' || currentChar == '\r')
382                 {
383                     goto endstate3;
384                 }
385 
386                 {
387                     inputCopy = inputCopy[1 .. $];
388                     goto state3;
389                 }
390             }
391             else
392             {
393                 string inputCopyNext = inputCopy;
394                 import std.utf;
395 
396                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
397 
398                 {
399                     inputCopy = inputCopyNext;
400                     goto state3;
401                 }
402             }
403         }
404         endstate3:
405         {
406             assert(inputCopy.ptr >= input.ptr);
407             foundSymbol = tokenID!"LineComment";
408             foundLength = inputCopy.ptr - input.ptr;
409             foundIsIgnore = true;
410             goto lexerend;
411         }
412 
413     state4:
414         // (BlockComment)
415         // path: [/] [*]
416         {
417             if (inputCopy.length == 0)
418             {
419                 if (input.ptr == inputCopy.ptr)
420                     goto lexerend;
421                 else if (foundSymbol != SymbolID.max)
422                     goto lexerend;
423                 else
424                     throw lexerException("EOF", "[^]", inputCopy.ptr - input.ptr);
425             }
426             char currentChar = inputCopy[0];
427             if (currentChar < 0x80)
428             {
429                 if (currentChar == '*')
430                 {
431                     inputCopy = inputCopy[1 .. $];
432                     goto state5;
433                 }
434                 else
435                 {
436                     inputCopy = inputCopy[1 .. $];
437                     goto state4;
438                 }
439             }
440             else
441             {
442                 string inputCopyNext = inputCopy;
443                 import std.utf;
444 
445                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
446 
447                 {
448                     inputCopy = inputCopyNext;
449                     goto state4;
450                 }
451             }
452         }
453 
454     state5:
455         // (BlockComment)
456         // path: [/] [*] [*]
457         {
458             if (inputCopy.length == 0)
459             {
460                 if (input.ptr == inputCopy.ptr)
461                     goto lexerend;
462                 else if (foundSymbol != SymbolID.max)
463                     goto lexerend;
464                 else
465                     throw lexerException("EOF", "[^]", inputCopy.ptr - input.ptr);
466             }
467             char currentChar = inputCopy[0];
468             if (currentChar < 0x80)
469             {
470                 if (currentChar == '*')
471                 {
472                     inputCopy = inputCopy[1 .. $];
473                     goto state5;
474                 }
475                 else if (currentChar == '/')
476                 {
477                     inputCopy = inputCopy[1 .. $];
478                     goto state6;
479                 }
480                 else
481                 {
482                     inputCopy = inputCopy[1 .. $];
483                     goto state4;
484                 }
485             }
486             else
487             {
488                 string inputCopyNext = inputCopy;
489                 import std.utf;
490 
491                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
492 
493                 {
494                     inputCopy = inputCopyNext;
495                     goto state4;
496                 }
497             }
498         }
499 
500     state6:
501         // BlockComment
502         // path: [/] [*] [*] [/]
503         {
504             if (inputCopy.length == 0)
505                 goto endstate6;
506             goto endstate6;
507         }
508         endstate6:
509         {
510             assert(inputCopy.ptr >= input.ptr);
511             foundSymbol = tokenID!"BlockComment";
512             foundLength = inputCopy.ptr - input.ptr;
513             foundIsIgnore = true;
514             goto lexerend;
515         }
516 
517     state7:
518         // (NestingBlockComment)
519         // path: [/] [+]
520         {
521             // RecursiveLexer
522             if (lexPart0(inputCopy, foundSymbol != SymbolID.max))
523                 goto state8;
524             else
525                 goto lexerend;
526         }
527 
528     state8:
529         // NestingBlockComment
530         // path: [/] [+] []
531         {
532             if (inputCopy.length == 0)
533                 goto endstate8;
534             goto endstate8;
535         }
536         endstate8:
537         {
538             assert(inputCopy.ptr >= input.ptr);
539             foundSymbol = tokenID!"NestingBlockComment";
540             foundLength = inputCopy.ptr - input.ptr;
541             foundIsIgnore = true;
542             goto lexerend;
543         }
544 
545     state9:
546         // Identifier ("fragment")
547         // path: [f]
548         {
549             if (inputCopy.length == 0)
550                 goto endstate9;
551             char currentChar = inputCopy[0];
552             if (currentChar < 0x80)
553             {
554                 if (currentChar == 'r')
555                 {
556                     inputCopy = inputCopy[1 .. $];
557                     goto state10;
558                 }
559                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
560                 {
561                     inputCopy = inputCopy[1 .. $];
562                     goto state17;
563                 }
564                 else
565                 {
566                     goto endstate9;
567                 }
568             }
569             else
570             {
571                 string inputCopyNext = inputCopy;
572                 import std.utf;
573 
574                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
575 
576                 {
577                     goto endstate9;
578                 }
579             }
580         }
581         endstate9:
582         {
583             assert(inputCopy.ptr >= input.ptr);
584             foundSymbol = tokenID!"Identifier";
585             foundLength = inputCopy.ptr - input.ptr;
586             foundIsIgnore = false;
587             goto lexerend;
588         }
589 
590     state10:
591         // Identifier ("fragment")
592         // path: [f] [r]
593         {
594             if (inputCopy.length == 0)
595                 goto endstate10;
596             char currentChar = inputCopy[0];
597             if (currentChar < 0x80)
598             {
599                 if (currentChar == 'a')
600                 {
601                     inputCopy = inputCopy[1 .. $];
602                     goto state11;
603                 }
604                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'b' && currentChar <= 'z'))
605                 {
606                     inputCopy = inputCopy[1 .. $];
607                     goto state17;
608                 }
609                 else
610                 {
611                     goto endstate10;
612                 }
613             }
614             else
615             {
616                 string inputCopyNext = inputCopy;
617                 import std.utf;
618 
619                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
620 
621                 {
622                     goto endstate10;
623                 }
624             }
625         }
626         endstate10:
627         {
628             assert(inputCopy.ptr >= input.ptr);
629             foundSymbol = tokenID!"Identifier";
630             foundLength = inputCopy.ptr - input.ptr;
631             foundIsIgnore = false;
632             goto lexerend;
633         }
634 
635     state11:
636         // Identifier ("fragment")
637         // path: [f] [r] [a]
638         {
639             if (inputCopy.length == 0)
640                 goto endstate11;
641             char currentChar = inputCopy[0];
642             if (currentChar < 0x80)
643             {
644                 if (currentChar == 'g')
645                 {
646                     inputCopy = inputCopy[1 .. $];
647                     goto state12;
648                 }
649                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
650                 {
651                     inputCopy = inputCopy[1 .. $];
652                     goto state17;
653                 }
654                 else
655                 {
656                     goto endstate11;
657                 }
658             }
659             else
660             {
661                 string inputCopyNext = inputCopy;
662                 import std.utf;
663 
664                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
665 
666                 {
667                     goto endstate11;
668                 }
669             }
670         }
671         endstate11:
672         {
673             assert(inputCopy.ptr >= input.ptr);
674             foundSymbol = tokenID!"Identifier";
675             foundLength = inputCopy.ptr - input.ptr;
676             foundIsIgnore = false;
677             goto lexerend;
678         }
679 
680     state12:
681         // Identifier ("fragment")
682         // path: [f] [r] [a] [g]
683         {
684             if (inputCopy.length == 0)
685                 goto endstate12;
686             char currentChar = inputCopy[0];
687             if (currentChar < 0x80)
688             {
689                 if (currentChar == 'm')
690                 {
691                     inputCopy = inputCopy[1 .. $];
692                     goto state13;
693                 }
694                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
695                 {
696                     inputCopy = inputCopy[1 .. $];
697                     goto state17;
698                 }
699                 else
700                 {
701                     goto endstate12;
702                 }
703             }
704             else
705             {
706                 string inputCopyNext = inputCopy;
707                 import std.utf;
708 
709                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
710 
711                 {
712                     goto endstate12;
713                 }
714             }
715         }
716         endstate12:
717         {
718             assert(inputCopy.ptr >= input.ptr);
719             foundSymbol = tokenID!"Identifier";
720             foundLength = inputCopy.ptr - input.ptr;
721             foundIsIgnore = false;
722             goto lexerend;
723         }
724 
725     state13:
726         // Identifier ("fragment")
727         // path: [f] [r] [a] [g] [m]
728         {
729             if (inputCopy.length == 0)
730                 goto endstate13;
731             char currentChar = inputCopy[0];
732             if (currentChar < 0x80)
733             {
734                 if (currentChar == 'e')
735                 {
736                     inputCopy = inputCopy[1 .. $];
737                     goto state14;
738                 }
739                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
740                 {
741                     inputCopy = inputCopy[1 .. $];
742                     goto state17;
743                 }
744                 else
745                 {
746                     goto endstate13;
747                 }
748             }
749             else
750             {
751                 string inputCopyNext = inputCopy;
752                 import std.utf;
753 
754                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
755 
756                 {
757                     goto endstate13;
758                 }
759             }
760         }
761         endstate13:
762         {
763             assert(inputCopy.ptr >= input.ptr);
764             foundSymbol = tokenID!"Identifier";
765             foundLength = inputCopy.ptr - input.ptr;
766             foundIsIgnore = false;
767             goto lexerend;
768         }
769 
770     state14:
771         // Identifier ("fragment")
772         // path: [f] [r] [a] [g] [m] [e]
773         {
774             if (inputCopy.length == 0)
775                 goto endstate14;
776             char currentChar = inputCopy[0];
777             if (currentChar < 0x80)
778             {
779                 if (currentChar == 'n')
780                 {
781                     inputCopy = inputCopy[1 .. $];
782                     goto state15;
783                 }
784                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
785                 {
786                     inputCopy = inputCopy[1 .. $];
787                     goto state17;
788                 }
789                 else
790                 {
791                     goto endstate14;
792                 }
793             }
794             else
795             {
796                 string inputCopyNext = inputCopy;
797                 import std.utf;
798 
799                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
800 
801                 {
802                     goto endstate14;
803                 }
804             }
805         }
806         endstate14:
807         {
808             assert(inputCopy.ptr >= input.ptr);
809             foundSymbol = tokenID!"Identifier";
810             foundLength = inputCopy.ptr - input.ptr;
811             foundIsIgnore = false;
812             goto lexerend;
813         }
814 
815     state15:
816         // Identifier ("fragment")
817         // path: [f] [r] [a] [g] [m] [e] [n]
818         {
819             if (inputCopy.length == 0)
820                 goto endstate15;
821             char currentChar = inputCopy[0];
822             if (currentChar < 0x80)
823             {
824                 if (currentChar == 't')
825                 {
826                     inputCopy = inputCopy[1 .. $];
827                     goto state16;
828                 }
829                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
830                 {
831                     inputCopy = inputCopy[1 .. $];
832                     goto state17;
833                 }
834                 else
835                 {
836                     goto endstate15;
837                 }
838             }
839             else
840             {
841                 string inputCopyNext = inputCopy;
842                 import std.utf;
843 
844                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
845 
846                 {
847                     goto endstate15;
848                 }
849             }
850         }
851         endstate15:
852         {
853             assert(inputCopy.ptr >= input.ptr);
854             foundSymbol = tokenID!"Identifier";
855             foundLength = inputCopy.ptr - input.ptr;
856             foundIsIgnore = false;
857             goto lexerend;
858         }
859 
860     state16:
861         // "fragment" Identifier
862         // path: [f] [r] [a] [g] [m] [e] [n] [t]
863         {
864             if (inputCopy.length == 0)
865                 goto endstate16;
866             char currentChar = inputCopy[0];
867             if (currentChar < 0x80)
868             {
869                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
870                 {
871                     assert(inputCopy.ptr >= input.ptr);
872                     foundSymbol = tokenID!"\"fragment\"";
873                     foundLength = inputCopy.ptr - input.ptr;
874                     foundIsIgnore = false;
875                     inputCopy = inputCopy[1 .. $];
876                     goto state17;
877                 }
878                 else
879                 {
880                     goto endstate16;
881                 }
882             }
883             else
884             {
885                 string inputCopyNext = inputCopy;
886                 import std.utf;
887 
888                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
889 
890                 {
891                     goto endstate16;
892                 }
893             }
894         }
895         endstate16:
896         {
897             assert(inputCopy.ptr >= input.ptr);
898             foundSymbol = tokenID!"\"fragment\"";
899             foundLength = inputCopy.ptr - input.ptr;
900             foundIsIgnore = false;
901             goto lexerend;
902         }
903 
904     state17:
905         // Identifier
906         // path: [A-Z_b-eg-hj-lnp-su-z]
907         {
908             if (inputCopy.length == 0)
909                 goto endstate17;
910             char currentChar = inputCopy[0];
911             if (currentChar < 0x80)
912             {
913                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
914                 {
915                     inputCopy = inputCopy[1 .. $];
916                     goto state17;
917                 }
918                 else
919                 {
920                     goto endstate17;
921                 }
922             }
923             else
924             {
925                 string inputCopyNext = inputCopy;
926                 import std.utf;
927 
928                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
929 
930                 {
931                     goto endstate17;
932                 }
933             }
934         }
935         endstate17:
936         {
937             assert(inputCopy.ptr >= input.ptr);
938             foundSymbol = tokenID!"Identifier";
939             foundLength = inputCopy.ptr - input.ptr;
940             foundIsIgnore = false;
941             goto lexerend;
942         }
943 
944     state18:
945         // Identifier ("anytoken")
946         // path: [a]
947         {
948             if (inputCopy.length == 0)
949                 goto endstate18;
950             char currentChar = inputCopy[0];
951             if (currentChar < 0x80)
952             {
953                 if (currentChar == 'n')
954                 {
955                     inputCopy = inputCopy[1 .. $];
956                     goto state19;
957                 }
958                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
959                 {
960                     inputCopy = inputCopy[1 .. $];
961                     goto state17;
962                 }
963                 else
964                 {
965                     goto endstate18;
966                 }
967             }
968             else
969             {
970                 string inputCopyNext = inputCopy;
971                 import std.utf;
972 
973                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
974 
975                 {
976                     goto endstate18;
977                 }
978             }
979         }
980         endstate18:
981         {
982             assert(inputCopy.ptr >= input.ptr);
983             foundSymbol = tokenID!"Identifier";
984             foundLength = inputCopy.ptr - input.ptr;
985             foundIsIgnore = false;
986             goto lexerend;
987         }
988 
989     state19:
990         // Identifier ("anytoken")
991         // path: [a] [n]
992         {
993             if (inputCopy.length == 0)
994                 goto endstate19;
995             char currentChar = inputCopy[0];
996             if (currentChar < 0x80)
997             {
998                 if (currentChar == 'y')
999                 {
1000                     inputCopy = inputCopy[1 .. $];
1001                     goto state20;
1002                 }
1003                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1004                 {
1005                     inputCopy = inputCopy[1 .. $];
1006                     goto state17;
1007                 }
1008                 else
1009                 {
1010                     goto endstate19;
1011                 }
1012             }
1013             else
1014             {
1015                 string inputCopyNext = inputCopy;
1016                 import std.utf;
1017 
1018                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1019 
1020                 {
1021                     goto endstate19;
1022                 }
1023             }
1024         }
1025         endstate19:
1026         {
1027             assert(inputCopy.ptr >= input.ptr);
1028             foundSymbol = tokenID!"Identifier";
1029             foundLength = inputCopy.ptr - input.ptr;
1030             foundIsIgnore = false;
1031             goto lexerend;
1032         }
1033 
1034     state20:
1035         // Identifier ("anytoken")
1036         // path: [a] [n] [y]
1037         {
1038             if (inputCopy.length == 0)
1039                 goto endstate20;
1040             char currentChar = inputCopy[0];
1041             if (currentChar < 0x80)
1042             {
1043                 if (currentChar == 't')
1044                 {
1045                     inputCopy = inputCopy[1 .. $];
1046                     goto state21;
1047                 }
1048                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1049                 {
1050                     inputCopy = inputCopy[1 .. $];
1051                     goto state17;
1052                 }
1053                 else
1054                 {
1055                     goto endstate20;
1056                 }
1057             }
1058             else
1059             {
1060                 string inputCopyNext = inputCopy;
1061                 import std.utf;
1062 
1063                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1064 
1065                 {
1066                     goto endstate20;
1067                 }
1068             }
1069         }
1070         endstate20:
1071         {
1072             assert(inputCopy.ptr >= input.ptr);
1073             foundSymbol = tokenID!"Identifier";
1074             foundLength = inputCopy.ptr - input.ptr;
1075             foundIsIgnore = false;
1076             goto lexerend;
1077         }
1078 
1079     state21:
1080         // Identifier ("anytoken")
1081         // path: [a] [n] [y] [t]
1082         {
1083             if (inputCopy.length == 0)
1084                 goto endstate21;
1085             char currentChar = inputCopy[0];
1086             if (currentChar < 0x80)
1087             {
1088                 if (currentChar == 'o')
1089                 {
1090                     inputCopy = inputCopy[1 .. $];
1091                     goto state22;
1092                 }
1093                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1094                 {
1095                     inputCopy = inputCopy[1 .. $];
1096                     goto state17;
1097                 }
1098                 else
1099                 {
1100                     goto endstate21;
1101                 }
1102             }
1103             else
1104             {
1105                 string inputCopyNext = inputCopy;
1106                 import std.utf;
1107 
1108                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1109 
1110                 {
1111                     goto endstate21;
1112                 }
1113             }
1114         }
1115         endstate21:
1116         {
1117             assert(inputCopy.ptr >= input.ptr);
1118             foundSymbol = tokenID!"Identifier";
1119             foundLength = inputCopy.ptr - input.ptr;
1120             foundIsIgnore = false;
1121             goto lexerend;
1122         }
1123 
1124     state22:
1125         // Identifier ("anytoken")
1126         // path: [a] [n] [y] [t] [o]
1127         {
1128             if (inputCopy.length == 0)
1129                 goto endstate22;
1130             char currentChar = inputCopy[0];
1131             if (currentChar < 0x80)
1132             {
1133                 if (currentChar == 'k')
1134                 {
1135                     inputCopy = inputCopy[1 .. $];
1136                     goto state23;
1137                 }
1138                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1139                 {
1140                     inputCopy = inputCopy[1 .. $];
1141                     goto state17;
1142                 }
1143                 else
1144                 {
1145                     goto endstate22;
1146                 }
1147             }
1148             else
1149             {
1150                 string inputCopyNext = inputCopy;
1151                 import std.utf;
1152 
1153                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1154 
1155                 {
1156                     goto endstate22;
1157                 }
1158             }
1159         }
1160         endstate22:
1161         {
1162             assert(inputCopy.ptr >= input.ptr);
1163             foundSymbol = tokenID!"Identifier";
1164             foundLength = inputCopy.ptr - input.ptr;
1165             foundIsIgnore = false;
1166             goto lexerend;
1167         }
1168 
1169     state23:
1170         // Identifier ("anytoken")
1171         // path: [a] [n] [y] [t] [o] [k]
1172         {
1173             if (inputCopy.length == 0)
1174                 goto endstate23;
1175             char currentChar = inputCopy[0];
1176             if (currentChar < 0x80)
1177             {
1178                 if (currentChar == 'e')
1179                 {
1180                     inputCopy = inputCopy[1 .. $];
1181                     goto state24;
1182                 }
1183                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1184                 {
1185                     inputCopy = inputCopy[1 .. $];
1186                     goto state17;
1187                 }
1188                 else
1189                 {
1190                     goto endstate23;
1191                 }
1192             }
1193             else
1194             {
1195                 string inputCopyNext = inputCopy;
1196                 import std.utf;
1197 
1198                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1199 
1200                 {
1201                     goto endstate23;
1202                 }
1203             }
1204         }
1205         endstate23:
1206         {
1207             assert(inputCopy.ptr >= input.ptr);
1208             foundSymbol = tokenID!"Identifier";
1209             foundLength = inputCopy.ptr - input.ptr;
1210             foundIsIgnore = false;
1211             goto lexerend;
1212         }
1213 
1214     state24:
1215         // Identifier ("anytoken")
1216         // path: [a] [n] [y] [t] [o] [k] [e]
1217         {
1218             if (inputCopy.length == 0)
1219                 goto endstate24;
1220             char currentChar = inputCopy[0];
1221             if (currentChar < 0x80)
1222             {
1223                 if (currentChar == 'n')
1224                 {
1225                     inputCopy = inputCopy[1 .. $];
1226                     goto state25;
1227                 }
1228                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1229                 {
1230                     inputCopy = inputCopy[1 .. $];
1231                     goto state17;
1232                 }
1233                 else
1234                 {
1235                     goto endstate24;
1236                 }
1237             }
1238             else
1239             {
1240                 string inputCopyNext = inputCopy;
1241                 import std.utf;
1242 
1243                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1244 
1245                 {
1246                     goto endstate24;
1247                 }
1248             }
1249         }
1250         endstate24:
1251         {
1252             assert(inputCopy.ptr >= input.ptr);
1253             foundSymbol = tokenID!"Identifier";
1254             foundLength = inputCopy.ptr - input.ptr;
1255             foundIsIgnore = false;
1256             goto lexerend;
1257         }
1258 
1259     state25:
1260         // "anytoken" Identifier
1261         // path: [a] [n] [y] [t] [o] [k] [e] [n]
1262         {
1263             if (inputCopy.length == 0)
1264                 goto endstate25;
1265             char currentChar = inputCopy[0];
1266             if (currentChar < 0x80)
1267             {
1268                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1269                 {
1270                     assert(inputCopy.ptr >= input.ptr);
1271                     foundSymbol = tokenID!"\"anytoken\"";
1272                     foundLength = inputCopy.ptr - input.ptr;
1273                     foundIsIgnore = false;
1274                     inputCopy = inputCopy[1 .. $];
1275                     goto state17;
1276                 }
1277                 else
1278                 {
1279                     goto endstate25;
1280                 }
1281             }
1282             else
1283             {
1284                 string inputCopyNext = inputCopy;
1285                 import std.utf;
1286 
1287                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1288 
1289                 {
1290                     goto endstate25;
1291                 }
1292             }
1293         }
1294         endstate25:
1295         {
1296             assert(inputCopy.ptr >= input.ptr);
1297             foundSymbol = tokenID!"\"anytoken\"";
1298             foundLength = inputCopy.ptr - input.ptr;
1299             foundIsIgnore = false;
1300             goto lexerend;
1301         }
1302 
1303     state26:
1304         // Identifier ("match")
1305         // path: [m]
1306         {
1307             if (inputCopy.length == 0)
1308                 goto endstate26;
1309             char currentChar = inputCopy[0];
1310             if (currentChar < 0x80)
1311             {
1312                 if (currentChar == 'a')
1313                 {
1314                     inputCopy = inputCopy[1 .. $];
1315                     goto state27;
1316                 }
1317                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'b' && currentChar <= 'z'))
1318                 {
1319                     inputCopy = inputCopy[1 .. $];
1320                     goto state17;
1321                 }
1322                 else
1323                 {
1324                     goto endstate26;
1325                 }
1326             }
1327             else
1328             {
1329                 string inputCopyNext = inputCopy;
1330                 import std.utf;
1331 
1332                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1333 
1334                 {
1335                     goto endstate26;
1336                 }
1337             }
1338         }
1339         endstate26:
1340         {
1341             assert(inputCopy.ptr >= input.ptr);
1342             foundSymbol = tokenID!"Identifier";
1343             foundLength = inputCopy.ptr - input.ptr;
1344             foundIsIgnore = false;
1345             goto lexerend;
1346         }
1347 
1348     state27:
1349         // Identifier ("match")
1350         // path: [m] [a]
1351         {
1352             if (inputCopy.length == 0)
1353                 goto endstate27;
1354             char currentChar = inputCopy[0];
1355             if (currentChar < 0x80)
1356             {
1357                 if (currentChar == 't')
1358                 {
1359                     inputCopy = inputCopy[1 .. $];
1360                     goto state28;
1361                 }
1362                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1363                 {
1364                     inputCopy = inputCopy[1 .. $];
1365                     goto state17;
1366                 }
1367                 else
1368                 {
1369                     goto endstate27;
1370                 }
1371             }
1372             else
1373             {
1374                 string inputCopyNext = inputCopy;
1375                 import std.utf;
1376 
1377                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1378 
1379                 {
1380                     goto endstate27;
1381                 }
1382             }
1383         }
1384         endstate27:
1385         {
1386             assert(inputCopy.ptr >= input.ptr);
1387             foundSymbol = tokenID!"Identifier";
1388             foundLength = inputCopy.ptr - input.ptr;
1389             foundIsIgnore = false;
1390             goto lexerend;
1391         }
1392 
1393     state28:
1394         // Identifier ("match")
1395         // path: [m] [a] [t]
1396         {
1397             if (inputCopy.length == 0)
1398                 goto endstate28;
1399             char currentChar = inputCopy[0];
1400             if (currentChar < 0x80)
1401             {
1402                 if (currentChar == 'c')
1403                 {
1404                     inputCopy = inputCopy[1 .. $];
1405                     goto state29;
1406                 }
1407                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1408                 {
1409                     inputCopy = inputCopy[1 .. $];
1410                     goto state17;
1411                 }
1412                 else
1413                 {
1414                     goto endstate28;
1415                 }
1416             }
1417             else
1418             {
1419                 string inputCopyNext = inputCopy;
1420                 import std.utf;
1421 
1422                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1423 
1424                 {
1425                     goto endstate28;
1426                 }
1427             }
1428         }
1429         endstate28:
1430         {
1431             assert(inputCopy.ptr >= input.ptr);
1432             foundSymbol = tokenID!"Identifier";
1433             foundLength = inputCopy.ptr - input.ptr;
1434             foundIsIgnore = false;
1435             goto lexerend;
1436         }
1437 
1438     state29:
1439         // Identifier ("match")
1440         // path: [m] [a] [t] [c]
1441         {
1442             if (inputCopy.length == 0)
1443                 goto endstate29;
1444             char currentChar = inputCopy[0];
1445             if (currentChar < 0x80)
1446             {
1447                 if (currentChar == 'h')
1448                 {
1449                     inputCopy = inputCopy[1 .. $];
1450                     goto state30;
1451                 }
1452                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1453                 {
1454                     inputCopy = inputCopy[1 .. $];
1455                     goto state17;
1456                 }
1457                 else
1458                 {
1459                     goto endstate29;
1460                 }
1461             }
1462             else
1463             {
1464                 string inputCopyNext = inputCopy;
1465                 import std.utf;
1466 
1467                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1468 
1469                 {
1470                     goto endstate29;
1471                 }
1472             }
1473         }
1474         endstate29:
1475         {
1476             assert(inputCopy.ptr >= input.ptr);
1477             foundSymbol = tokenID!"Identifier";
1478             foundLength = inputCopy.ptr - input.ptr;
1479             foundIsIgnore = false;
1480             goto lexerend;
1481         }
1482 
1483     state30:
1484         // "match" Identifier
1485         // path: [m] [a] [t] [c] [h]
1486         {
1487             if (inputCopy.length == 0)
1488                 goto endstate30;
1489             char currentChar = inputCopy[0];
1490             if (currentChar < 0x80)
1491             {
1492                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1493                 {
1494                     assert(inputCopy.ptr >= input.ptr);
1495                     foundSymbol = tokenID!"\"match\"";
1496                     foundLength = inputCopy.ptr - input.ptr;
1497                     foundIsIgnore = false;
1498                     inputCopy = inputCopy[1 .. $];
1499                     goto state17;
1500                 }
1501                 else
1502                 {
1503                     goto endstate30;
1504                 }
1505             }
1506             else
1507             {
1508                 string inputCopyNext = inputCopy;
1509                 import std.utf;
1510 
1511                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1512 
1513                 {
1514                     goto endstate30;
1515                 }
1516             }
1517         }
1518         endstate30:
1519         {
1520             assert(inputCopy.ptr >= input.ptr);
1521             foundSymbol = tokenID!"\"match\"";
1522             foundLength = inputCopy.ptr - input.ptr;
1523             foundIsIgnore = false;
1524             goto lexerend;
1525         }
1526 
1527     state31:
1528         // Identifier ("token") ("t(")
1529         // path: [t]
1530         {
1531             if (inputCopy.length == 0)
1532                 goto endstate31;
1533             char currentChar = inputCopy[0];
1534             if (currentChar < 0x80)
1535             {
1536                 if (currentChar == '(')
1537                 {
1538                     assert(inputCopy.ptr >= input.ptr);
1539                     foundSymbol = tokenID!"Identifier";
1540                     foundLength = inputCopy.ptr - input.ptr;
1541                     foundIsIgnore = false;
1542                     inputCopy = inputCopy[1 .. $];
1543                     goto state36;
1544                 }
1545                 else if (currentChar == 'o')
1546                 {
1547                     inputCopy = inputCopy[1 .. $];
1548                     goto state32;
1549                 }
1550                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1551                 {
1552                     inputCopy = inputCopy[1 .. $];
1553                     goto state17;
1554                 }
1555                 else
1556                 {
1557                     goto endstate31;
1558                 }
1559             }
1560             else
1561             {
1562                 string inputCopyNext = inputCopy;
1563                 import std.utf;
1564 
1565                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1566 
1567                 {
1568                     goto endstate31;
1569                 }
1570             }
1571         }
1572         endstate31:
1573         {
1574             assert(inputCopy.ptr >= input.ptr);
1575             foundSymbol = tokenID!"Identifier";
1576             foundLength = inputCopy.ptr - input.ptr;
1577             foundIsIgnore = false;
1578             goto lexerend;
1579         }
1580 
1581     state32:
1582         // Identifier ("token")
1583         // path: [t] [o]
1584         {
1585             if (inputCopy.length == 0)
1586                 goto endstate32;
1587             char currentChar = inputCopy[0];
1588             if (currentChar < 0x80)
1589             {
1590                 if (currentChar == 'k')
1591                 {
1592                     inputCopy = inputCopy[1 .. $];
1593                     goto state33;
1594                 }
1595                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1596                 {
1597                     inputCopy = inputCopy[1 .. $];
1598                     goto state17;
1599                 }
1600                 else
1601                 {
1602                     goto endstate32;
1603                 }
1604             }
1605             else
1606             {
1607                 string inputCopyNext = inputCopy;
1608                 import std.utf;
1609 
1610                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1611 
1612                 {
1613                     goto endstate32;
1614                 }
1615             }
1616         }
1617         endstate32:
1618         {
1619             assert(inputCopy.ptr >= input.ptr);
1620             foundSymbol = tokenID!"Identifier";
1621             foundLength = inputCopy.ptr - input.ptr;
1622             foundIsIgnore = false;
1623             goto lexerend;
1624         }
1625 
1626     state33:
1627         // Identifier ("token")
1628         // path: [t] [o] [k]
1629         {
1630             if (inputCopy.length == 0)
1631                 goto endstate33;
1632             char currentChar = inputCopy[0];
1633             if (currentChar < 0x80)
1634             {
1635                 if (currentChar == 'e')
1636                 {
1637                     inputCopy = inputCopy[1 .. $];
1638                     goto state34;
1639                 }
1640                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1641                 {
1642                     inputCopy = inputCopy[1 .. $];
1643                     goto state17;
1644                 }
1645                 else
1646                 {
1647                     goto endstate33;
1648                 }
1649             }
1650             else
1651             {
1652                 string inputCopyNext = inputCopy;
1653                 import std.utf;
1654 
1655                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1656 
1657                 {
1658                     goto endstate33;
1659                 }
1660             }
1661         }
1662         endstate33:
1663         {
1664             assert(inputCopy.ptr >= input.ptr);
1665             foundSymbol = tokenID!"Identifier";
1666             foundLength = inputCopy.ptr - input.ptr;
1667             foundIsIgnore = false;
1668             goto lexerend;
1669         }
1670 
1671     state34:
1672         // Identifier ("token")
1673         // path: [t] [o] [k] [e]
1674         {
1675             if (inputCopy.length == 0)
1676                 goto endstate34;
1677             char currentChar = inputCopy[0];
1678             if (currentChar < 0x80)
1679             {
1680                 if (currentChar == 'n')
1681                 {
1682                     inputCopy = inputCopy[1 .. $];
1683                     goto state35;
1684                 }
1685                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1686                 {
1687                     inputCopy = inputCopy[1 .. $];
1688                     goto state17;
1689                 }
1690                 else
1691                 {
1692                     goto endstate34;
1693                 }
1694             }
1695             else
1696             {
1697                 string inputCopyNext = inputCopy;
1698                 import std.utf;
1699 
1700                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1701 
1702                 {
1703                     goto endstate34;
1704                 }
1705             }
1706         }
1707         endstate34:
1708         {
1709             assert(inputCopy.ptr >= input.ptr);
1710             foundSymbol = tokenID!"Identifier";
1711             foundLength = inputCopy.ptr - input.ptr;
1712             foundIsIgnore = false;
1713             goto lexerend;
1714         }
1715 
1716     state35:
1717         // "token" Identifier
1718         // path: [t] [o] [k] [e] [n]
1719         {
1720             if (inputCopy.length == 0)
1721                 goto endstate35;
1722             char currentChar = inputCopy[0];
1723             if (currentChar < 0x80)
1724             {
1725                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1726                 {
1727                     assert(inputCopy.ptr >= input.ptr);
1728                     foundSymbol = tokenID!"\"token\"";
1729                     foundLength = inputCopy.ptr - input.ptr;
1730                     foundIsIgnore = false;
1731                     inputCopy = inputCopy[1 .. $];
1732                     goto state17;
1733                 }
1734                 else
1735                 {
1736                     goto endstate35;
1737                 }
1738             }
1739             else
1740             {
1741                 string inputCopyNext = inputCopy;
1742                 import std.utf;
1743 
1744                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1745 
1746                 {
1747                     goto endstate35;
1748                 }
1749             }
1750         }
1751         endstate35:
1752         {
1753             assert(inputCopy.ptr >= input.ptr);
1754             foundSymbol = tokenID!"\"token\"";
1755             foundLength = inputCopy.ptr - input.ptr;
1756             foundIsIgnore = false;
1757             goto lexerend;
1758         }
1759 
1760     state36:
1761         // "t("
1762         // path: [t] [(]
1763         {
1764             if (inputCopy.length == 0)
1765                 goto endstate36;
1766             goto endstate36;
1767         }
1768         endstate36:
1769         {
1770             assert(inputCopy.ptr >= input.ptr);
1771             foundSymbol = tokenID!"\"t(\"";
1772             foundLength = inputCopy.ptr - input.ptr;
1773             foundIsIgnore = false;
1774             goto lexerend;
1775         }
1776 
1777     state37:
1778         // Identifier ("option")
1779         // path: [o]
1780         {
1781             if (inputCopy.length == 0)
1782                 goto endstate37;
1783             char currentChar = inputCopy[0];
1784             if (currentChar < 0x80)
1785             {
1786                 if (currentChar == 'p')
1787                 {
1788                     inputCopy = inputCopy[1 .. $];
1789                     goto state38;
1790                 }
1791                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1792                 {
1793                     inputCopy = inputCopy[1 .. $];
1794                     goto state17;
1795                 }
1796                 else
1797                 {
1798                     goto endstate37;
1799                 }
1800             }
1801             else
1802             {
1803                 string inputCopyNext = inputCopy;
1804                 import std.utf;
1805 
1806                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1807 
1808                 {
1809                     goto endstate37;
1810                 }
1811             }
1812         }
1813         endstate37:
1814         {
1815             assert(inputCopy.ptr >= input.ptr);
1816             foundSymbol = tokenID!"Identifier";
1817             foundLength = inputCopy.ptr - input.ptr;
1818             foundIsIgnore = false;
1819             goto lexerend;
1820         }
1821 
1822     state38:
1823         // Identifier ("option")
1824         // path: [o] [p]
1825         {
1826             if (inputCopy.length == 0)
1827                 goto endstate38;
1828             char currentChar = inputCopy[0];
1829             if (currentChar < 0x80)
1830             {
1831                 if (currentChar == 't')
1832                 {
1833                     inputCopy = inputCopy[1 .. $];
1834                     goto state39;
1835                 }
1836                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1837                 {
1838                     inputCopy = inputCopy[1 .. $];
1839                     goto state17;
1840                 }
1841                 else
1842                 {
1843                     goto endstate38;
1844                 }
1845             }
1846             else
1847             {
1848                 string inputCopyNext = inputCopy;
1849                 import std.utf;
1850 
1851                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1852 
1853                 {
1854                     goto endstate38;
1855                 }
1856             }
1857         }
1858         endstate38:
1859         {
1860             assert(inputCopy.ptr >= input.ptr);
1861             foundSymbol = tokenID!"Identifier";
1862             foundLength = inputCopy.ptr - input.ptr;
1863             foundIsIgnore = false;
1864             goto lexerend;
1865         }
1866 
1867     state39:
1868         // Identifier ("option")
1869         // path: [o] [p] [t]
1870         {
1871             if (inputCopy.length == 0)
1872                 goto endstate39;
1873             char currentChar = inputCopy[0];
1874             if (currentChar < 0x80)
1875             {
1876                 if (currentChar == 'i')
1877                 {
1878                     inputCopy = inputCopy[1 .. $];
1879                     goto state40;
1880                 }
1881                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1882                 {
1883                     inputCopy = inputCopy[1 .. $];
1884                     goto state17;
1885                 }
1886                 else
1887                 {
1888                     goto endstate39;
1889                 }
1890             }
1891             else
1892             {
1893                 string inputCopyNext = inputCopy;
1894                 import std.utf;
1895 
1896                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1897 
1898                 {
1899                     goto endstate39;
1900                 }
1901             }
1902         }
1903         endstate39:
1904         {
1905             assert(inputCopy.ptr >= input.ptr);
1906             foundSymbol = tokenID!"Identifier";
1907             foundLength = inputCopy.ptr - input.ptr;
1908             foundIsIgnore = false;
1909             goto lexerend;
1910         }
1911 
1912     state40:
1913         // Identifier ("option")
1914         // path: [o] [p] [t] [i]
1915         {
1916             if (inputCopy.length == 0)
1917                 goto endstate40;
1918             char currentChar = inputCopy[0];
1919             if (currentChar < 0x80)
1920             {
1921                 if (currentChar == 'o')
1922                 {
1923                     inputCopy = inputCopy[1 .. $];
1924                     goto state41;
1925                 }
1926                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1927                 {
1928                     inputCopy = inputCopy[1 .. $];
1929                     goto state17;
1930                 }
1931                 else
1932                 {
1933                     goto endstate40;
1934                 }
1935             }
1936             else
1937             {
1938                 string inputCopyNext = inputCopy;
1939                 import std.utf;
1940 
1941                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1942 
1943                 {
1944                     goto endstate40;
1945                 }
1946             }
1947         }
1948         endstate40:
1949         {
1950             assert(inputCopy.ptr >= input.ptr);
1951             foundSymbol = tokenID!"Identifier";
1952             foundLength = inputCopy.ptr - input.ptr;
1953             foundIsIgnore = false;
1954             goto lexerend;
1955         }
1956 
1957     state41:
1958         // Identifier ("option")
1959         // path: [o] [p] [t] [i] [o]
1960         {
1961             if (inputCopy.length == 0)
1962                 goto endstate41;
1963             char currentChar = inputCopy[0];
1964             if (currentChar < 0x80)
1965             {
1966                 if (currentChar == 'n')
1967                 {
1968                     inputCopy = inputCopy[1 .. $];
1969                     goto state42;
1970                 }
1971                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
1972                 {
1973                     inputCopy = inputCopy[1 .. $];
1974                     goto state17;
1975                 }
1976                 else
1977                 {
1978                     goto endstate41;
1979                 }
1980             }
1981             else
1982             {
1983                 string inputCopyNext = inputCopy;
1984                 import std.utf;
1985 
1986                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
1987 
1988                 {
1989                     goto endstate41;
1990                 }
1991             }
1992         }
1993         endstate41:
1994         {
1995             assert(inputCopy.ptr >= input.ptr);
1996             foundSymbol = tokenID!"Identifier";
1997             foundLength = inputCopy.ptr - input.ptr;
1998             foundIsIgnore = false;
1999             goto lexerend;
2000         }
2001 
2002     state42:
2003         // "option" Identifier
2004         // path: [o] [p] [t] [i] [o] [n]
2005         {
2006             if (inputCopy.length == 0)
2007                 goto endstate42;
2008             char currentChar = inputCopy[0];
2009             if (currentChar < 0x80)
2010             {
2011                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2012                 {
2013                     assert(inputCopy.ptr >= input.ptr);
2014                     foundSymbol = tokenID!"\"option\"";
2015                     foundLength = inputCopy.ptr - input.ptr;
2016                     foundIsIgnore = false;
2017                     inputCopy = inputCopy[1 .. $];
2018                     goto state17;
2019                 }
2020                 else
2021                 {
2022                     goto endstate42;
2023                 }
2024             }
2025             else
2026             {
2027                 string inputCopyNext = inputCopy;
2028                 import std.utf;
2029 
2030                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2031 
2032                 {
2033                     goto endstate42;
2034                 }
2035             }
2036         }
2037         endstate42:
2038         {
2039             assert(inputCopy.ptr >= input.ptr);
2040             foundSymbol = tokenID!"\"option\"";
2041             foundLength = inputCopy.ptr - input.ptr;
2042             foundIsIgnore = false;
2043             goto lexerend;
2044         }
2045 
2046     state43:
2047         // Identifier ("import")
2048         // path: [i]
2049         {
2050             if (inputCopy.length == 0)
2051                 goto endstate43;
2052             char currentChar = inputCopy[0];
2053             if (currentChar < 0x80)
2054             {
2055                 if (currentChar == 'm')
2056                 {
2057                     inputCopy = inputCopy[1 .. $];
2058                     goto state44;
2059                 }
2060                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2061                 {
2062                     inputCopy = inputCopy[1 .. $];
2063                     goto state17;
2064                 }
2065                 else
2066                 {
2067                     goto endstate43;
2068                 }
2069             }
2070             else
2071             {
2072                 string inputCopyNext = inputCopy;
2073                 import std.utf;
2074 
2075                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2076 
2077                 {
2078                     goto endstate43;
2079                 }
2080             }
2081         }
2082         endstate43:
2083         {
2084             assert(inputCopy.ptr >= input.ptr);
2085             foundSymbol = tokenID!"Identifier";
2086             foundLength = inputCopy.ptr - input.ptr;
2087             foundIsIgnore = false;
2088             goto lexerend;
2089         }
2090 
2091     state44:
2092         // Identifier ("import")
2093         // path: [i] [m]
2094         {
2095             if (inputCopy.length == 0)
2096                 goto endstate44;
2097             char currentChar = inputCopy[0];
2098             if (currentChar < 0x80)
2099             {
2100                 if (currentChar == 'p')
2101                 {
2102                     inputCopy = inputCopy[1 .. $];
2103                     goto state45;
2104                 }
2105                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2106                 {
2107                     inputCopy = inputCopy[1 .. $];
2108                     goto state17;
2109                 }
2110                 else
2111                 {
2112                     goto endstate44;
2113                 }
2114             }
2115             else
2116             {
2117                 string inputCopyNext = inputCopy;
2118                 import std.utf;
2119 
2120                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2121 
2122                 {
2123                     goto endstate44;
2124                 }
2125             }
2126         }
2127         endstate44:
2128         {
2129             assert(inputCopy.ptr >= input.ptr);
2130             foundSymbol = tokenID!"Identifier";
2131             foundLength = inputCopy.ptr - input.ptr;
2132             foundIsIgnore = false;
2133             goto lexerend;
2134         }
2135 
2136     state45:
2137         // Identifier ("import")
2138         // path: [i] [m] [p]
2139         {
2140             if (inputCopy.length == 0)
2141                 goto endstate45;
2142             char currentChar = inputCopy[0];
2143             if (currentChar < 0x80)
2144             {
2145                 if (currentChar == 'o')
2146                 {
2147                     inputCopy = inputCopy[1 .. $];
2148                     goto state46;
2149                 }
2150                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2151                 {
2152                     inputCopy = inputCopy[1 .. $];
2153                     goto state17;
2154                 }
2155                 else
2156                 {
2157                     goto endstate45;
2158                 }
2159             }
2160             else
2161             {
2162                 string inputCopyNext = inputCopy;
2163                 import std.utf;
2164 
2165                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2166 
2167                 {
2168                     goto endstate45;
2169                 }
2170             }
2171         }
2172         endstate45:
2173         {
2174             assert(inputCopy.ptr >= input.ptr);
2175             foundSymbol = tokenID!"Identifier";
2176             foundLength = inputCopy.ptr - input.ptr;
2177             foundIsIgnore = false;
2178             goto lexerend;
2179         }
2180 
2181     state46:
2182         // Identifier ("import")
2183         // path: [i] [m] [p] [o]
2184         {
2185             if (inputCopy.length == 0)
2186                 goto endstate46;
2187             char currentChar = inputCopy[0];
2188             if (currentChar < 0x80)
2189             {
2190                 if (currentChar == 'r')
2191                 {
2192                     inputCopy = inputCopy[1 .. $];
2193                     goto state47;
2194                 }
2195                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2196                 {
2197                     inputCopy = inputCopy[1 .. $];
2198                     goto state17;
2199                 }
2200                 else
2201                 {
2202                     goto endstate46;
2203                 }
2204             }
2205             else
2206             {
2207                 string inputCopyNext = inputCopy;
2208                 import std.utf;
2209 
2210                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2211 
2212                 {
2213                     goto endstate46;
2214                 }
2215             }
2216         }
2217         endstate46:
2218         {
2219             assert(inputCopy.ptr >= input.ptr);
2220             foundSymbol = tokenID!"Identifier";
2221             foundLength = inputCopy.ptr - input.ptr;
2222             foundIsIgnore = false;
2223             goto lexerend;
2224         }
2225 
2226     state47:
2227         // Identifier ("import")
2228         // path: [i] [m] [p] [o] [r]
2229         {
2230             if (inputCopy.length == 0)
2231                 goto endstate47;
2232             char currentChar = inputCopy[0];
2233             if (currentChar < 0x80)
2234             {
2235                 if (currentChar == 't')
2236                 {
2237                     inputCopy = inputCopy[1 .. $];
2238                     goto state48;
2239                 }
2240                 else if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2241                 {
2242                     inputCopy = inputCopy[1 .. $];
2243                     goto state17;
2244                 }
2245                 else
2246                 {
2247                     goto endstate47;
2248                 }
2249             }
2250             else
2251             {
2252                 string inputCopyNext = inputCopy;
2253                 import std.utf;
2254 
2255                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2256 
2257                 {
2258                     goto endstate47;
2259                 }
2260             }
2261         }
2262         endstate47:
2263         {
2264             assert(inputCopy.ptr >= input.ptr);
2265             foundSymbol = tokenID!"Identifier";
2266             foundLength = inputCopy.ptr - input.ptr;
2267             foundIsIgnore = false;
2268             goto lexerend;
2269         }
2270 
2271     state48:
2272         // "import" Identifier
2273         // path: [i] [m] [p] [o] [r] [t]
2274         {
2275             if (inputCopy.length == 0)
2276                 goto endstate48;
2277             char currentChar = inputCopy[0];
2278             if (currentChar < 0x80)
2279             {
2280                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'Z') || currentChar == '_' || (currentChar >= 'a' && currentChar <= 'z'))
2281                 {
2282                     assert(inputCopy.ptr >= input.ptr);
2283                     foundSymbol = tokenID!"\"import\"";
2284                     foundLength = inputCopy.ptr - input.ptr;
2285                     foundIsIgnore = false;
2286                     inputCopy = inputCopy[1 .. $];
2287                     goto state17;
2288                 }
2289                 else
2290                 {
2291                     goto endstate48;
2292                 }
2293             }
2294             else
2295             {
2296                 string inputCopyNext = inputCopy;
2297                 import std.utf;
2298 
2299                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2300 
2301                 {
2302                     goto endstate48;
2303                 }
2304             }
2305         }
2306         endstate48:
2307         {
2308             assert(inputCopy.ptr >= input.ptr);
2309             foundSymbol = tokenID!"\"import\"";
2310             foundLength = inputCopy.ptr - input.ptr;
2311             foundIsIgnore = false;
2312             goto lexerend;
2313         }
2314 
2315     state49:
2316         // (StringLiteral)
2317         // path: [\"]
2318         {
2319             if (inputCopy.length == 0)
2320             {
2321                 if (input.ptr == inputCopy.ptr)
2322                     goto lexerend;
2323                 else if (foundSymbol != SymbolID.max)
2324                     goto lexerend;
2325                 else
2326                     throw lexerException("EOF", "[^]", inputCopy.ptr - input.ptr);
2327             }
2328             char currentChar = inputCopy[0];
2329             if (currentChar < 0x80)
2330             {
2331                 if (currentChar == '\"')
2332                 {
2333                     inputCopy = inputCopy[1 .. $];
2334                     goto state50;
2335                 }
2336                 else if (currentChar == '\\')
2337                 {
2338                     inputCopy = inputCopy[1 .. $];
2339                     goto state51;
2340                 }
2341                 else
2342                 {
2343                     inputCopy = inputCopy[1 .. $];
2344                     goto state49;
2345                 }
2346             }
2347             else
2348             {
2349                 string inputCopyNext = inputCopy;
2350                 import std.utf;
2351 
2352                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2353 
2354                 {
2355                     inputCopy = inputCopyNext;
2356                     goto state49;
2357                 }
2358             }
2359         }
2360 
2361     state50:
2362         // StringLiteral
2363         // path: [\"] [\"]
2364         {
2365             if (inputCopy.length == 0)
2366                 goto endstate50;
2367             goto endstate50;
2368         }
2369         endstate50:
2370         {
2371             assert(inputCopy.ptr >= input.ptr);
2372             foundSymbol = tokenID!"StringLiteral";
2373             foundLength = inputCopy.ptr - input.ptr;
2374             foundIsIgnore = false;
2375             goto lexerend;
2376         }
2377 
2378     state51:
2379         // (StringLiteral)
2380         // path: [\"] [\\]
2381         {
2382             if (inputCopy.length == 0)
2383             {
2384                 if (input.ptr == inputCopy.ptr)
2385                     goto lexerend;
2386                 else if (foundSymbol != SymbolID.max)
2387                     goto lexerend;
2388                 else
2389                     throw lexerException("EOF", "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
2390             }
2391             char currentChar = inputCopy[0];
2392             if (currentChar < 0x80)
2393             {
2394                 if (currentChar == 'U')
2395                 {
2396                     inputCopy = inputCopy[1 .. $];
2397                     goto state56;
2398                 }
2399                 else if (currentChar == 'u')
2400                 {
2401                     inputCopy = inputCopy[1 .. $];
2402                     goto state54;
2403                 }
2404                 else if (currentChar == 'x')
2405                 {
2406                     inputCopy = inputCopy[1 .. $];
2407                     goto state52;
2408                 }
2409                 else if (currentChar == '\"' || currentChar == '\'' || currentChar == '-' || currentChar == '0' || (currentChar >= '[' && currentChar <= ']') || (currentChar >= 'a' && currentChar <= 'b') || currentChar == 'f' || currentChar == 'n' || currentChar == 'r' || (currentChar >= 't' && currentChar <= 'v'))
2410                 {
2411                     inputCopy = inputCopy[1 .. $];
2412                     goto state49;
2413                 }
2414                 else
2415                 {
2416                     if (foundSymbol != SymbolID.max)
2417                         goto lexerend;
2418                     else
2419                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
2420                 }
2421             }
2422             else
2423             {
2424                 string inputCopyNext = inputCopy;
2425                 import std.utf;
2426 
2427                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2428 
2429                 {
2430                     if (foundSymbol != SymbolID.max)
2431                         goto lexerend;
2432                     else
2433                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
2434                 }
2435             }
2436         }
2437 
2438     state52:
2439         // (StringLiteral)
2440         // path: [\"] [\\] [x]
2441         {
2442             if (inputCopy.length == 0)
2443             {
2444                 if (input.ptr == inputCopy.ptr)
2445                     goto lexerend;
2446                 else if (foundSymbol != SymbolID.max)
2447                     goto lexerend;
2448                 else
2449                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2450             }
2451             char currentChar = inputCopy[0];
2452             if (currentChar < 0x80)
2453             {
2454                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2455                 {
2456                     inputCopy = inputCopy[1 .. $];
2457                     goto state53;
2458                 }
2459                 else
2460                 {
2461                     if (foundSymbol != SymbolID.max)
2462                         goto lexerend;
2463                     else
2464                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2465                 }
2466             }
2467             else
2468             {
2469                 string inputCopyNext = inputCopy;
2470                 import std.utf;
2471 
2472                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2473 
2474                 {
2475                     if (foundSymbol != SymbolID.max)
2476                         goto lexerend;
2477                     else
2478                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2479                 }
2480             }
2481         }
2482 
2483     state53:
2484         // (StringLiteral)
2485         // path: [\"] [\\] [x] [0-9A-Fa-f]
2486         {
2487             if (inputCopy.length == 0)
2488             {
2489                 if (input.ptr == inputCopy.ptr)
2490                     goto lexerend;
2491                 else if (foundSymbol != SymbolID.max)
2492                     goto lexerend;
2493                 else
2494                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2495             }
2496             char currentChar = inputCopy[0];
2497             if (currentChar < 0x80)
2498             {
2499                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2500                 {
2501                     inputCopy = inputCopy[1 .. $];
2502                     goto state49;
2503                 }
2504                 else
2505                 {
2506                     if (foundSymbol != SymbolID.max)
2507                         goto lexerend;
2508                     else
2509                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2510                 }
2511             }
2512             else
2513             {
2514                 string inputCopyNext = inputCopy;
2515                 import std.utf;
2516 
2517                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2518 
2519                 {
2520                     if (foundSymbol != SymbolID.max)
2521                         goto lexerend;
2522                     else
2523                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2524                 }
2525             }
2526         }
2527 
2528     state54:
2529         // (StringLiteral)
2530         // path: [\"] [\\] [u]
2531         {
2532             if (inputCopy.length == 0)
2533             {
2534                 if (input.ptr == inputCopy.ptr)
2535                     goto lexerend;
2536                 else if (foundSymbol != SymbolID.max)
2537                     goto lexerend;
2538                 else
2539                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2540             }
2541             char currentChar = inputCopy[0];
2542             if (currentChar < 0x80)
2543             {
2544                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2545                 {
2546                     inputCopy = inputCopy[1 .. $];
2547                     goto state55;
2548                 }
2549                 else
2550                 {
2551                     if (foundSymbol != SymbolID.max)
2552                         goto lexerend;
2553                     else
2554                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2555                 }
2556             }
2557             else
2558             {
2559                 string inputCopyNext = inputCopy;
2560                 import std.utf;
2561 
2562                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2563 
2564                 {
2565                     if (foundSymbol != SymbolID.max)
2566                         goto lexerend;
2567                     else
2568                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2569                 }
2570             }
2571         }
2572 
2573     state55:
2574         // (StringLiteral)
2575         // path: [\"] [\\] [u] [0-9A-Fa-f]
2576         {
2577             if (inputCopy.length == 0)
2578             {
2579                 if (input.ptr == inputCopy.ptr)
2580                     goto lexerend;
2581                 else if (foundSymbol != SymbolID.max)
2582                     goto lexerend;
2583                 else
2584                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2585             }
2586             char currentChar = inputCopy[0];
2587             if (currentChar < 0x80)
2588             {
2589                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2590                 {
2591                     inputCopy = inputCopy[1 .. $];
2592                     goto state52;
2593                 }
2594                 else
2595                 {
2596                     if (foundSymbol != SymbolID.max)
2597                         goto lexerend;
2598                     else
2599                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2600                 }
2601             }
2602             else
2603             {
2604                 string inputCopyNext = inputCopy;
2605                 import std.utf;
2606 
2607                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2608 
2609                 {
2610                     if (foundSymbol != SymbolID.max)
2611                         goto lexerend;
2612                     else
2613                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2614                 }
2615             }
2616         }
2617 
2618     state56:
2619         // (StringLiteral)
2620         // path: [\"] [\\] [U]
2621         {
2622             if (inputCopy.length == 0)
2623             {
2624                 if (input.ptr == inputCopy.ptr)
2625                     goto lexerend;
2626                 else if (foundSymbol != SymbolID.max)
2627                     goto lexerend;
2628                 else
2629                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2630             }
2631             char currentChar = inputCopy[0];
2632             if (currentChar < 0x80)
2633             {
2634                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2635                 {
2636                     inputCopy = inputCopy[1 .. $];
2637                     goto state57;
2638                 }
2639                 else
2640                 {
2641                     if (foundSymbol != SymbolID.max)
2642                         goto lexerend;
2643                     else
2644                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2645                 }
2646             }
2647             else
2648             {
2649                 string inputCopyNext = inputCopy;
2650                 import std.utf;
2651 
2652                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2653 
2654                 {
2655                     if (foundSymbol != SymbolID.max)
2656                         goto lexerend;
2657                     else
2658                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2659                 }
2660             }
2661         }
2662 
2663     state57:
2664         // (StringLiteral)
2665         // path: [\"] [\\] [U] [0-9A-Fa-f]
2666         {
2667             if (inputCopy.length == 0)
2668             {
2669                 if (input.ptr == inputCopy.ptr)
2670                     goto lexerend;
2671                 else if (foundSymbol != SymbolID.max)
2672                     goto lexerend;
2673                 else
2674                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2675             }
2676             char currentChar = inputCopy[0];
2677             if (currentChar < 0x80)
2678             {
2679                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2680                 {
2681                     inputCopy = inputCopy[1 .. $];
2682                     goto state58;
2683                 }
2684                 else
2685                 {
2686                     if (foundSymbol != SymbolID.max)
2687                         goto lexerend;
2688                     else
2689                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2690                 }
2691             }
2692             else
2693             {
2694                 string inputCopyNext = inputCopy;
2695                 import std.utf;
2696 
2697                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2698 
2699                 {
2700                     if (foundSymbol != SymbolID.max)
2701                         goto lexerend;
2702                     else
2703                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2704                 }
2705             }
2706         }
2707 
2708     state58:
2709         // (StringLiteral)
2710         // path: [\"] [\\] [U] [0-9A-Fa-f] [0-9A-Fa-f]
2711         {
2712             if (inputCopy.length == 0)
2713             {
2714                 if (input.ptr == inputCopy.ptr)
2715                     goto lexerend;
2716                 else if (foundSymbol != SymbolID.max)
2717                     goto lexerend;
2718                 else
2719                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2720             }
2721             char currentChar = inputCopy[0];
2722             if (currentChar < 0x80)
2723             {
2724                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2725                 {
2726                     inputCopy = inputCopy[1 .. $];
2727                     goto state59;
2728                 }
2729                 else
2730                 {
2731                     if (foundSymbol != SymbolID.max)
2732                         goto lexerend;
2733                     else
2734                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2735                 }
2736             }
2737             else
2738             {
2739                 string inputCopyNext = inputCopy;
2740                 import std.utf;
2741 
2742                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2743 
2744                 {
2745                     if (foundSymbol != SymbolID.max)
2746                         goto lexerend;
2747                     else
2748                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2749                 }
2750             }
2751         }
2752 
2753     state59:
2754         // (StringLiteral)
2755         // path: [\"] [\\] [U] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f]
2756         {
2757             if (inputCopy.length == 0)
2758             {
2759                 if (input.ptr == inputCopy.ptr)
2760                     goto lexerend;
2761                 else if (foundSymbol != SymbolID.max)
2762                     goto lexerend;
2763                 else
2764                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2765             }
2766             char currentChar = inputCopy[0];
2767             if (currentChar < 0x80)
2768             {
2769                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
2770                 {
2771                     inputCopy = inputCopy[1 .. $];
2772                     goto state54;
2773                 }
2774                 else
2775                 {
2776                     if (foundSymbol != SymbolID.max)
2777                         goto lexerend;
2778                     else
2779                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2780                 }
2781             }
2782             else
2783             {
2784                 string inputCopyNext = inputCopy;
2785                 import std.utf;
2786 
2787                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2788 
2789                 {
2790                     if (foundSymbol != SymbolID.max)
2791                         goto lexerend;
2792                     else
2793                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
2794                 }
2795             }
2796         }
2797 
2798     state60:
2799         // (CharacterSetLiteral)
2800         // path: [\[]
2801         {
2802             if (inputCopy.length == 0)
2803             {
2804                 if (input.ptr == inputCopy.ptr)
2805                     goto lexerend;
2806                 else if (foundSymbol != SymbolID.max)
2807                     goto lexerend;
2808                 else
2809                     throw lexerException("EOF", "[^\\-\\[]", inputCopy.ptr - input.ptr);
2810             }
2811             char currentChar = inputCopy[0];
2812             if (currentChar < 0x80)
2813             {
2814                 if (currentChar == '\\')
2815                 {
2816                     inputCopy = inputCopy[1 .. $];
2817                     goto state63;
2818                 }
2819                 else if (currentChar == ']')
2820                 {
2821                     inputCopy = inputCopy[1 .. $];
2822                     goto state62;
2823                 }
2824                 else if (currentChar == '-' || currentChar == '[')
2825                 {
2826                     if (foundSymbol != SymbolID.max)
2827                         goto lexerend;
2828                     else
2829                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[^\\-\\[]", inputCopy.ptr - input.ptr);
2830                 }
2831                 else
2832                 {
2833                     inputCopy = inputCopy[1 .. $];
2834                     goto state61;
2835                 }
2836             }
2837             else
2838             {
2839                 string inputCopyNext = inputCopy;
2840                 import std.utf;
2841 
2842                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2843 
2844                 {
2845                     inputCopy = inputCopyNext;
2846                     goto state61;
2847                 }
2848             }
2849         }
2850 
2851     state61:
2852         // (CharacterSetLiteral)
2853         // path: [\[] [^\-\[-\]]
2854         {
2855             if (inputCopy.length == 0)
2856             {
2857                 if (input.ptr == inputCopy.ptr)
2858                     goto lexerend;
2859                 else if (foundSymbol != SymbolID.max)
2860                     goto lexerend;
2861                 else
2862                     throw lexerException("EOF", "[^\\[]", inputCopy.ptr - input.ptr);
2863             }
2864             char currentChar = inputCopy[0];
2865             if (currentChar < 0x80)
2866             {
2867                 if (currentChar == '-')
2868                 {
2869                     inputCopy = inputCopy[1 .. $];
2870                     goto state64;
2871                 }
2872                 else if (currentChar == '[')
2873                 {
2874                     if (foundSymbol != SymbolID.max)
2875                         goto lexerend;
2876                     else
2877                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[^\\[]", inputCopy.ptr - input.ptr);
2878                 }
2879                 else if (currentChar == '\\')
2880                 {
2881                     inputCopy = inputCopy[1 .. $];
2882                     goto state63;
2883                 }
2884                 else if (currentChar == ']')
2885                 {
2886                     inputCopy = inputCopy[1 .. $];
2887                     goto state62;
2888                 }
2889                 else
2890                 {
2891                     inputCopy = inputCopy[1 .. $];
2892                     goto state61;
2893                 }
2894             }
2895             else
2896             {
2897                 string inputCopyNext = inputCopy;
2898                 import std.utf;
2899 
2900                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2901 
2902                 {
2903                     inputCopy = inputCopyNext;
2904                     goto state61;
2905                 }
2906             }
2907         }
2908 
2909     state62:
2910         // CharacterSetLiteral
2911         // path: [\[] [\]]
2912         {
2913             if (inputCopy.length == 0)
2914                 goto endstate62;
2915             goto endstate62;
2916         }
2917         endstate62:
2918         {
2919             assert(inputCopy.ptr >= input.ptr);
2920             foundSymbol = tokenID!"CharacterSetLiteral";
2921             foundLength = inputCopy.ptr - input.ptr;
2922             foundIsIgnore = false;
2923             goto lexerend;
2924         }
2925 
2926     state63:
2927         // (CharacterSetLiteral)
2928         // path: [\[] [\\]
2929         {
2930             if (inputCopy.length == 0)
2931             {
2932                 if (input.ptr == inputCopy.ptr)
2933                     goto lexerend;
2934                 else if (foundSymbol != SymbolID.max)
2935                     goto lexerend;
2936                 else
2937                     throw lexerException("EOF", "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
2938             }
2939             char currentChar = inputCopy[0];
2940             if (currentChar < 0x80)
2941             {
2942                 if (currentChar == 'U')
2943                 {
2944                     inputCopy = inputCopy[1 .. $];
2945                     goto state78;
2946                 }
2947                 else if (currentChar == 'u')
2948                 {
2949                     inputCopy = inputCopy[1 .. $];
2950                     goto state76;
2951                 }
2952                 else if (currentChar == 'x')
2953                 {
2954                     inputCopy = inputCopy[1 .. $];
2955                     goto state74;
2956                 }
2957                 else if (currentChar == '\"' || currentChar == '\'' || currentChar == '-' || currentChar == '0' || (currentChar >= '[' && currentChar <= ']') || (currentChar >= 'a' && currentChar <= 'b') || currentChar == 'f' || currentChar == 'n' || currentChar == 'r' || (currentChar >= 't' && currentChar <= 'v'))
2958                 {
2959                     inputCopy = inputCopy[1 .. $];
2960                     goto state61;
2961                 }
2962                 else
2963                 {
2964                     if (foundSymbol != SymbolID.max)
2965                         goto lexerend;
2966                     else
2967                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
2968                 }
2969             }
2970             else
2971             {
2972                 string inputCopyNext = inputCopy;
2973                 import std.utf;
2974 
2975                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
2976 
2977                 {
2978                     if (foundSymbol != SymbolID.max)
2979                         goto lexerend;
2980                     else
2981                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
2982                 }
2983             }
2984         }
2985 
2986     state64:
2987         // (CharacterSetLiteral)
2988         // path: [\[] [^\-\[-\]] [\-]
2989         {
2990             if (inputCopy.length == 0)
2991             {
2992                 if (input.ptr == inputCopy.ptr)
2993                     goto lexerend;
2994                 else if (foundSymbol != SymbolID.max)
2995                     goto lexerend;
2996                 else
2997                     throw lexerException("EOF", "[^\\-\\[\\]]", inputCopy.ptr - input.ptr);
2998             }
2999             char currentChar = inputCopy[0];
3000             if (currentChar < 0x80)
3001             {
3002                 if (currentChar == '\\')
3003                 {
3004                     inputCopy = inputCopy[1 .. $];
3005                     goto state65;
3006                 }
3007                 else if (currentChar == '-' || (currentChar >= '[' && currentChar <= ']'))
3008                 {
3009                     if (foundSymbol != SymbolID.max)
3010                         goto lexerend;
3011                     else
3012                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[^\\-\\[\\]]", inputCopy.ptr - input.ptr);
3013                 }
3014                 else
3015                 {
3016                     inputCopy = inputCopy[1 .. $];
3017                     goto state60;
3018                 }
3019             }
3020             else
3021             {
3022                 string inputCopyNext = inputCopy;
3023                 import std.utf;
3024 
3025                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3026 
3027                 {
3028                     inputCopy = inputCopyNext;
3029                     goto state60;
3030                 }
3031             }
3032         }
3033 
3034     state65:
3035         // (CharacterSetLiteral)
3036         // path: [\[] [^\-\[-\]] [\-] [\\]
3037         {
3038             if (inputCopy.length == 0)
3039             {
3040                 if (input.ptr == inputCopy.ptr)
3041                     goto lexerend;
3042                 else if (foundSymbol != SymbolID.max)
3043                     goto lexerend;
3044                 else
3045                     throw lexerException("EOF", "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
3046             }
3047             char currentChar = inputCopy[0];
3048             if (currentChar < 0x80)
3049             {
3050                 if (currentChar == 'U')
3051                 {
3052                     inputCopy = inputCopy[1 .. $];
3053                     goto state70;
3054                 }
3055                 else if (currentChar == 'u')
3056                 {
3057                     inputCopy = inputCopy[1 .. $];
3058                     goto state68;
3059                 }
3060                 else if (currentChar == 'x')
3061                 {
3062                     inputCopy = inputCopy[1 .. $];
3063                     goto state66;
3064                 }
3065                 else if (currentChar == '\"' || currentChar == '\'' || currentChar == '-' || currentChar == '0' || (currentChar >= '[' && currentChar <= ']') || (currentChar >= 'a' && currentChar <= 'b') || currentChar == 'f' || currentChar == 'n' || currentChar == 'r' || (currentChar >= 't' && currentChar <= 'v'))
3066                 {
3067                     inputCopy = inputCopy[1 .. $];
3068                     goto state60;
3069                 }
3070                 else
3071                 {
3072                     if (foundSymbol != SymbolID.max)
3073                         goto lexerend;
3074                     else
3075                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
3076                 }
3077             }
3078             else
3079             {
3080                 string inputCopyNext = inputCopy;
3081                 import std.utf;
3082 
3083                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3084 
3085                 {
3086                     if (foundSymbol != SymbolID.max)
3087                         goto lexerend;
3088                     else
3089                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[\\\"\\\'\\-0U\\[-\\]a-bfnrt-vx]", inputCopy.ptr - input.ptr);
3090                 }
3091             }
3092         }
3093 
3094     state66:
3095         // (CharacterSetLiteral)
3096         // path: [\[] [^\-\[-\]] [\-] [\\] [x]
3097         {
3098             if (inputCopy.length == 0)
3099             {
3100                 if (input.ptr == inputCopy.ptr)
3101                     goto lexerend;
3102                 else if (foundSymbol != SymbolID.max)
3103                     goto lexerend;
3104                 else
3105                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3106             }
3107             char currentChar = inputCopy[0];
3108             if (currentChar < 0x80)
3109             {
3110                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3111                 {
3112                     inputCopy = inputCopy[1 .. $];
3113                     goto state67;
3114                 }
3115                 else
3116                 {
3117                     if (foundSymbol != SymbolID.max)
3118                         goto lexerend;
3119                     else
3120                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3121                 }
3122             }
3123             else
3124             {
3125                 string inputCopyNext = inputCopy;
3126                 import std.utf;
3127 
3128                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3129 
3130                 {
3131                     if (foundSymbol != SymbolID.max)
3132                         goto lexerend;
3133                     else
3134                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3135                 }
3136             }
3137         }
3138 
3139     state67:
3140         // (CharacterSetLiteral)
3141         // path: [\[] [^\-\[-\]] [\-] [\\] [x] [0-9A-Fa-f]
3142         {
3143             if (inputCopy.length == 0)
3144             {
3145                 if (input.ptr == inputCopy.ptr)
3146                     goto lexerend;
3147                 else if (foundSymbol != SymbolID.max)
3148                     goto lexerend;
3149                 else
3150                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3151             }
3152             char currentChar = inputCopy[0];
3153             if (currentChar < 0x80)
3154             {
3155                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3156                 {
3157                     inputCopy = inputCopy[1 .. $];
3158                     goto state60;
3159                 }
3160                 else
3161                 {
3162                     if (foundSymbol != SymbolID.max)
3163                         goto lexerend;
3164                     else
3165                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3166                 }
3167             }
3168             else
3169             {
3170                 string inputCopyNext = inputCopy;
3171                 import std.utf;
3172 
3173                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3174 
3175                 {
3176                     if (foundSymbol != SymbolID.max)
3177                         goto lexerend;
3178                     else
3179                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3180                 }
3181             }
3182         }
3183 
3184     state68:
3185         // (CharacterSetLiteral)
3186         // path: [\[] [^\-\[-\]] [\-] [\\] [u]
3187         {
3188             if (inputCopy.length == 0)
3189             {
3190                 if (input.ptr == inputCopy.ptr)
3191                     goto lexerend;
3192                 else if (foundSymbol != SymbolID.max)
3193                     goto lexerend;
3194                 else
3195                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3196             }
3197             char currentChar = inputCopy[0];
3198             if (currentChar < 0x80)
3199             {
3200                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3201                 {
3202                     inputCopy = inputCopy[1 .. $];
3203                     goto state69;
3204                 }
3205                 else
3206                 {
3207                     if (foundSymbol != SymbolID.max)
3208                         goto lexerend;
3209                     else
3210                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3211                 }
3212             }
3213             else
3214             {
3215                 string inputCopyNext = inputCopy;
3216                 import std.utf;
3217 
3218                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3219 
3220                 {
3221                     if (foundSymbol != SymbolID.max)
3222                         goto lexerend;
3223                     else
3224                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3225                 }
3226             }
3227         }
3228 
3229     state69:
3230         // (CharacterSetLiteral)
3231         // path: [\[] [^\-\[-\]] [\-] [\\] [u] [0-9A-Fa-f]
3232         {
3233             if (inputCopy.length == 0)
3234             {
3235                 if (input.ptr == inputCopy.ptr)
3236                     goto lexerend;
3237                 else if (foundSymbol != SymbolID.max)
3238                     goto lexerend;
3239                 else
3240                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3241             }
3242             char currentChar = inputCopy[0];
3243             if (currentChar < 0x80)
3244             {
3245                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3246                 {
3247                     inputCopy = inputCopy[1 .. $];
3248                     goto state66;
3249                 }
3250                 else
3251                 {
3252                     if (foundSymbol != SymbolID.max)
3253                         goto lexerend;
3254                     else
3255                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3256                 }
3257             }
3258             else
3259             {
3260                 string inputCopyNext = inputCopy;
3261                 import std.utf;
3262 
3263                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3264 
3265                 {
3266                     if (foundSymbol != SymbolID.max)
3267                         goto lexerend;
3268                     else
3269                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3270                 }
3271             }
3272         }
3273 
3274     state70:
3275         // (CharacterSetLiteral)
3276         // path: [\[] [^\-\[-\]] [\-] [\\] [U]
3277         {
3278             if (inputCopy.length == 0)
3279             {
3280                 if (input.ptr == inputCopy.ptr)
3281                     goto lexerend;
3282                 else if (foundSymbol != SymbolID.max)
3283                     goto lexerend;
3284                 else
3285                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3286             }
3287             char currentChar = inputCopy[0];
3288             if (currentChar < 0x80)
3289             {
3290                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3291                 {
3292                     inputCopy = inputCopy[1 .. $];
3293                     goto state71;
3294                 }
3295                 else
3296                 {
3297                     if (foundSymbol != SymbolID.max)
3298                         goto lexerend;
3299                     else
3300                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3301                 }
3302             }
3303             else
3304             {
3305                 string inputCopyNext = inputCopy;
3306                 import std.utf;
3307 
3308                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3309 
3310                 {
3311                     if (foundSymbol != SymbolID.max)
3312                         goto lexerend;
3313                     else
3314                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3315                 }
3316             }
3317         }
3318 
3319     state71:
3320         // (CharacterSetLiteral)
3321         // path: [\[] [^\-\[-\]] [\-] [\\] [U] [0-9A-Fa-f]
3322         {
3323             if (inputCopy.length == 0)
3324             {
3325                 if (input.ptr == inputCopy.ptr)
3326                     goto lexerend;
3327                 else if (foundSymbol != SymbolID.max)
3328                     goto lexerend;
3329                 else
3330                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3331             }
3332             char currentChar = inputCopy[0];
3333             if (currentChar < 0x80)
3334             {
3335                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3336                 {
3337                     inputCopy = inputCopy[1 .. $];
3338                     goto state72;
3339                 }
3340                 else
3341                 {
3342                     if (foundSymbol != SymbolID.max)
3343                         goto lexerend;
3344                     else
3345                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3346                 }
3347             }
3348             else
3349             {
3350                 string inputCopyNext = inputCopy;
3351                 import std.utf;
3352 
3353                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3354 
3355                 {
3356                     if (foundSymbol != SymbolID.max)
3357                         goto lexerend;
3358                     else
3359                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3360                 }
3361             }
3362         }
3363 
3364     state72:
3365         // (CharacterSetLiteral)
3366         // path: [\[] [^\-\[-\]] [\-] [\\] [U] [0-9A-Fa-f] [0-9A-Fa-f]
3367         {
3368             if (inputCopy.length == 0)
3369             {
3370                 if (input.ptr == inputCopy.ptr)
3371                     goto lexerend;
3372                 else if (foundSymbol != SymbolID.max)
3373                     goto lexerend;
3374                 else
3375                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3376             }
3377             char currentChar = inputCopy[0];
3378             if (currentChar < 0x80)
3379             {
3380                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3381                 {
3382                     inputCopy = inputCopy[1 .. $];
3383                     goto state73;
3384                 }
3385                 else
3386                 {
3387                     if (foundSymbol != SymbolID.max)
3388                         goto lexerend;
3389                     else
3390                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3391                 }
3392             }
3393             else
3394             {
3395                 string inputCopyNext = inputCopy;
3396                 import std.utf;
3397 
3398                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3399 
3400                 {
3401                     if (foundSymbol != SymbolID.max)
3402                         goto lexerend;
3403                     else
3404                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3405                 }
3406             }
3407         }
3408 
3409     state73:
3410         // (CharacterSetLiteral)
3411         // path: [\[] [^\-\[-\]] [\-] [\\] [U] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f]
3412         {
3413             if (inputCopy.length == 0)
3414             {
3415                 if (input.ptr == inputCopy.ptr)
3416                     goto lexerend;
3417                 else if (foundSymbol != SymbolID.max)
3418                     goto lexerend;
3419                 else
3420                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3421             }
3422             char currentChar = inputCopy[0];
3423             if (currentChar < 0x80)
3424             {
3425                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3426                 {
3427                     inputCopy = inputCopy[1 .. $];
3428                     goto state68;
3429                 }
3430                 else
3431                 {
3432                     if (foundSymbol != SymbolID.max)
3433                         goto lexerend;
3434                     else
3435                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3436                 }
3437             }
3438             else
3439             {
3440                 string inputCopyNext = inputCopy;
3441                 import std.utf;
3442 
3443                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3444 
3445                 {
3446                     if (foundSymbol != SymbolID.max)
3447                         goto lexerend;
3448                     else
3449                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3450                 }
3451             }
3452         }
3453 
3454     state74:
3455         // (CharacterSetLiteral)
3456         // path: [\[] [\\] [x]
3457         {
3458             if (inputCopy.length == 0)
3459             {
3460                 if (input.ptr == inputCopy.ptr)
3461                     goto lexerend;
3462                 else if (foundSymbol != SymbolID.max)
3463                     goto lexerend;
3464                 else
3465                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3466             }
3467             char currentChar = inputCopy[0];
3468             if (currentChar < 0x80)
3469             {
3470                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3471                 {
3472                     inputCopy = inputCopy[1 .. $];
3473                     goto state75;
3474                 }
3475                 else
3476                 {
3477                     if (foundSymbol != SymbolID.max)
3478                         goto lexerend;
3479                     else
3480                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3481                 }
3482             }
3483             else
3484             {
3485                 string inputCopyNext = inputCopy;
3486                 import std.utf;
3487 
3488                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3489 
3490                 {
3491                     if (foundSymbol != SymbolID.max)
3492                         goto lexerend;
3493                     else
3494                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3495                 }
3496             }
3497         }
3498 
3499     state75:
3500         // (CharacterSetLiteral)
3501         // path: [\[] [\\] [x] [0-9A-Fa-f]
3502         {
3503             if (inputCopy.length == 0)
3504             {
3505                 if (input.ptr == inputCopy.ptr)
3506                     goto lexerend;
3507                 else if (foundSymbol != SymbolID.max)
3508                     goto lexerend;
3509                 else
3510                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3511             }
3512             char currentChar = inputCopy[0];
3513             if (currentChar < 0x80)
3514             {
3515                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3516                 {
3517                     inputCopy = inputCopy[1 .. $];
3518                     goto state61;
3519                 }
3520                 else
3521                 {
3522                     if (foundSymbol != SymbolID.max)
3523                         goto lexerend;
3524                     else
3525                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3526                 }
3527             }
3528             else
3529             {
3530                 string inputCopyNext = inputCopy;
3531                 import std.utf;
3532 
3533                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3534 
3535                 {
3536                     if (foundSymbol != SymbolID.max)
3537                         goto lexerend;
3538                     else
3539                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3540                 }
3541             }
3542         }
3543 
3544     state76:
3545         // (CharacterSetLiteral)
3546         // path: [\[] [\\] [u]
3547         {
3548             if (inputCopy.length == 0)
3549             {
3550                 if (input.ptr == inputCopy.ptr)
3551                     goto lexerend;
3552                 else if (foundSymbol != SymbolID.max)
3553                     goto lexerend;
3554                 else
3555                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3556             }
3557             char currentChar = inputCopy[0];
3558             if (currentChar < 0x80)
3559             {
3560                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3561                 {
3562                     inputCopy = inputCopy[1 .. $];
3563                     goto state77;
3564                 }
3565                 else
3566                 {
3567                     if (foundSymbol != SymbolID.max)
3568                         goto lexerend;
3569                     else
3570                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3571                 }
3572             }
3573             else
3574             {
3575                 string inputCopyNext = inputCopy;
3576                 import std.utf;
3577 
3578                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3579 
3580                 {
3581                     if (foundSymbol != SymbolID.max)
3582                         goto lexerend;
3583                     else
3584                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3585                 }
3586             }
3587         }
3588 
3589     state77:
3590         // (CharacterSetLiteral)
3591         // path: [\[] [\\] [u] [0-9A-Fa-f]
3592         {
3593             if (inputCopy.length == 0)
3594             {
3595                 if (input.ptr == inputCopy.ptr)
3596                     goto lexerend;
3597                 else if (foundSymbol != SymbolID.max)
3598                     goto lexerend;
3599                 else
3600                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3601             }
3602             char currentChar = inputCopy[0];
3603             if (currentChar < 0x80)
3604             {
3605                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3606                 {
3607                     inputCopy = inputCopy[1 .. $];
3608                     goto state74;
3609                 }
3610                 else
3611                 {
3612                     if (foundSymbol != SymbolID.max)
3613                         goto lexerend;
3614                     else
3615                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3616                 }
3617             }
3618             else
3619             {
3620                 string inputCopyNext = inputCopy;
3621                 import std.utf;
3622 
3623                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3624 
3625                 {
3626                     if (foundSymbol != SymbolID.max)
3627                         goto lexerend;
3628                     else
3629                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3630                 }
3631             }
3632         }
3633 
3634     state78:
3635         // (CharacterSetLiteral)
3636         // path: [\[] [\\] [U]
3637         {
3638             if (inputCopy.length == 0)
3639             {
3640                 if (input.ptr == inputCopy.ptr)
3641                     goto lexerend;
3642                 else if (foundSymbol != SymbolID.max)
3643                     goto lexerend;
3644                 else
3645                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3646             }
3647             char currentChar = inputCopy[0];
3648             if (currentChar < 0x80)
3649             {
3650                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3651                 {
3652                     inputCopy = inputCopy[1 .. $];
3653                     goto state79;
3654                 }
3655                 else
3656                 {
3657                     if (foundSymbol != SymbolID.max)
3658                         goto lexerend;
3659                     else
3660                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3661                 }
3662             }
3663             else
3664             {
3665                 string inputCopyNext = inputCopy;
3666                 import std.utf;
3667 
3668                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3669 
3670                 {
3671                     if (foundSymbol != SymbolID.max)
3672                         goto lexerend;
3673                     else
3674                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3675                 }
3676             }
3677         }
3678 
3679     state79:
3680         // (CharacterSetLiteral)
3681         // path: [\[] [\\] [U] [0-9A-Fa-f]
3682         {
3683             if (inputCopy.length == 0)
3684             {
3685                 if (input.ptr == inputCopy.ptr)
3686                     goto lexerend;
3687                 else if (foundSymbol != SymbolID.max)
3688                     goto lexerend;
3689                 else
3690                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3691             }
3692             char currentChar = inputCopy[0];
3693             if (currentChar < 0x80)
3694             {
3695                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3696                 {
3697                     inputCopy = inputCopy[1 .. $];
3698                     goto state80;
3699                 }
3700                 else
3701                 {
3702                     if (foundSymbol != SymbolID.max)
3703                         goto lexerend;
3704                     else
3705                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3706                 }
3707             }
3708             else
3709             {
3710                 string inputCopyNext = inputCopy;
3711                 import std.utf;
3712 
3713                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3714 
3715                 {
3716                     if (foundSymbol != SymbolID.max)
3717                         goto lexerend;
3718                     else
3719                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3720                 }
3721             }
3722         }
3723 
3724     state80:
3725         // (CharacterSetLiteral)
3726         // path: [\[] [\\] [U] [0-9A-Fa-f] [0-9A-Fa-f]
3727         {
3728             if (inputCopy.length == 0)
3729             {
3730                 if (input.ptr == inputCopy.ptr)
3731                     goto lexerend;
3732                 else if (foundSymbol != SymbolID.max)
3733                     goto lexerend;
3734                 else
3735                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3736             }
3737             char currentChar = inputCopy[0];
3738             if (currentChar < 0x80)
3739             {
3740                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3741                 {
3742                     inputCopy = inputCopy[1 .. $];
3743                     goto state81;
3744                 }
3745                 else
3746                 {
3747                     if (foundSymbol != SymbolID.max)
3748                         goto lexerend;
3749                     else
3750                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3751                 }
3752             }
3753             else
3754             {
3755                 string inputCopyNext = inputCopy;
3756                 import std.utf;
3757 
3758                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3759 
3760                 {
3761                     if (foundSymbol != SymbolID.max)
3762                         goto lexerend;
3763                     else
3764                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3765                 }
3766             }
3767         }
3768 
3769     state81:
3770         // (CharacterSetLiteral)
3771         // path: [\[] [\\] [U] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f]
3772         {
3773             if (inputCopy.length == 0)
3774             {
3775                 if (input.ptr == inputCopy.ptr)
3776                     goto lexerend;
3777                 else if (foundSymbol != SymbolID.max)
3778                     goto lexerend;
3779                 else
3780                     throw lexerException("EOF", "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3781             }
3782             char currentChar = inputCopy[0];
3783             if (currentChar < 0x80)
3784             {
3785                 if ((currentChar >= '0' && currentChar <= '9') || (currentChar >= 'A' && currentChar <= 'F') || (currentChar >= 'a' && currentChar <= 'f'))
3786                 {
3787                     inputCopy = inputCopy[1 .. $];
3788                     goto state76;
3789                 }
3790                 else
3791                 {
3792                     if (foundSymbol != SymbolID.max)
3793                         goto lexerend;
3794                     else
3795                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3796                 }
3797             }
3798             else
3799             {
3800                 string inputCopyNext = inputCopy;
3801                 import std.utf;
3802 
3803                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3804 
3805                 {
3806                     if (foundSymbol != SymbolID.max)
3807                         goto lexerend;
3808                     else
3809                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[0-9A-Fa-f]", inputCopy.ptr - input.ptr);
3810                 }
3811             }
3812         }
3813 
3814     state82:
3815         // IntegerLiteral
3816         // path: [1-9]
3817         {
3818             if (inputCopy.length == 0)
3819                 goto endstate82;
3820             char currentChar = inputCopy[0];
3821             if (currentChar < 0x80)
3822             {
3823                 if ((currentChar >= '0' && currentChar <= '9'))
3824                 {
3825                     inputCopy = inputCopy[1 .. $];
3826                     goto state82;
3827                 }
3828                 else
3829                 {
3830                     goto endstate82;
3831                 }
3832             }
3833             else
3834             {
3835                 string inputCopyNext = inputCopy;
3836                 import std.utf;
3837 
3838                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3839 
3840                 {
3841                     goto endstate82;
3842                 }
3843             }
3844         }
3845         endstate82:
3846         {
3847             assert(inputCopy.ptr >= input.ptr);
3848             foundSymbol = tokenID!"IntegerLiteral";
3849             foundLength = inputCopy.ptr - input.ptr;
3850             foundIsIgnore = false;
3851             goto lexerend;
3852         }
3853 
3854     state83:
3855         // IntegerLiteral
3856         // path: [0]
3857         {
3858             if (inputCopy.length == 0)
3859                 goto endstate83;
3860             goto endstate83;
3861         }
3862         endstate83:
3863         {
3864             assert(inputCopy.ptr >= input.ptr);
3865             foundSymbol = tokenID!"IntegerLiteral";
3866             foundLength = inputCopy.ptr - input.ptr;
3867             foundIsIgnore = false;
3868             goto lexerend;
3869         }
3870 
3871     state84:
3872         // ";"
3873         // path: [;]
3874         {
3875             if (inputCopy.length == 0)
3876                 goto endstate84;
3877             goto endstate84;
3878         }
3879         endstate84:
3880         {
3881             assert(inputCopy.ptr >= input.ptr);
3882             foundSymbol = tokenID!"\";\"";
3883             foundLength = inputCopy.ptr - input.ptr;
3884             foundIsIgnore = false;
3885             goto lexerend;
3886         }
3887 
3888     state85:
3889         // "="
3890         // path: [=]
3891         {
3892             if (inputCopy.length == 0)
3893                 goto endstate85;
3894             goto endstate85;
3895         }
3896         endstate85:
3897         {
3898             assert(inputCopy.ptr >= input.ptr);
3899             foundSymbol = tokenID!"\"=\"";
3900             foundLength = inputCopy.ptr - input.ptr;
3901             foundIsIgnore = false;
3902             goto lexerend;
3903         }
3904 
3905     state86:
3906         // "("
3907         // path: [(]
3908         {
3909             if (inputCopy.length == 0)
3910                 goto endstate86;
3911             goto endstate86;
3912         }
3913         endstate86:
3914         {
3915             assert(inputCopy.ptr >= input.ptr);
3916             foundSymbol = tokenID!"\"(\"";
3917             foundLength = inputCopy.ptr - input.ptr;
3918             foundIsIgnore = false;
3919             goto lexerend;
3920         }
3921 
3922     state87:
3923         // ")"
3924         // path: [)]
3925         {
3926             if (inputCopy.length == 0)
3927                 goto endstate87;
3928             goto endstate87;
3929         }
3930         endstate87:
3931         {
3932             assert(inputCopy.ptr >= input.ptr);
3933             foundSymbol = tokenID!"\")\"";
3934             foundLength = inputCopy.ptr - input.ptr;
3935             foundIsIgnore = false;
3936             goto lexerend;
3937         }
3938 
3939     state88:
3940         // ","
3941         // path: [,]
3942         {
3943             if (inputCopy.length == 0)
3944                 goto endstate88;
3945             goto endstate88;
3946         }
3947         endstate88:
3948         {
3949             assert(inputCopy.ptr >= input.ptr);
3950             foundSymbol = tokenID!"\",\"";
3951             foundLength = inputCopy.ptr - input.ptr;
3952             foundIsIgnore = false;
3953             goto lexerend;
3954         }
3955 
3956     state89:
3957         // ("...")
3958         // path: [.]
3959         {
3960             if (inputCopy.length == 0)
3961             {
3962                 if (input.ptr == inputCopy.ptr)
3963                     goto lexerend;
3964                 else if (foundSymbol != SymbolID.max)
3965                     goto lexerend;
3966                 else
3967                     throw lexerException("EOF", "[.]", inputCopy.ptr - input.ptr);
3968             }
3969             char currentChar = inputCopy[0];
3970             if (currentChar < 0x80)
3971             {
3972                 if (currentChar == '.')
3973                 {
3974                     inputCopy = inputCopy[1 .. $];
3975                     goto state90;
3976                 }
3977                 else
3978                 {
3979                     if (foundSymbol != SymbolID.max)
3980                         goto lexerend;
3981                     else
3982                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[.]", inputCopy.ptr - input.ptr);
3983                 }
3984             }
3985             else
3986             {
3987                 string inputCopyNext = inputCopy;
3988                 import std.utf;
3989 
3990                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
3991 
3992                 {
3993                     if (foundSymbol != SymbolID.max)
3994                         goto lexerend;
3995                     else
3996                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[.]", inputCopy.ptr - input.ptr);
3997                 }
3998             }
3999         }
4000 
4001     state90:
4002         // ("...")
4003         // path: [.] [.]
4004         {
4005             if (inputCopy.length == 0)
4006             {
4007                 if (input.ptr == inputCopy.ptr)
4008                     goto lexerend;
4009                 else if (foundSymbol != SymbolID.max)
4010                     goto lexerend;
4011                 else
4012                     throw lexerException("EOF", "[.]", inputCopy.ptr - input.ptr);
4013             }
4014             char currentChar = inputCopy[0];
4015             if (currentChar < 0x80)
4016             {
4017                 if (currentChar == '.')
4018                 {
4019                     inputCopy = inputCopy[1 .. $];
4020                     goto state91;
4021                 }
4022                 else
4023                 {
4024                     if (foundSymbol != SymbolID.max)
4025                         goto lexerend;
4026                     else
4027                         throw lexerException(text("Error unexpected \'", currentChar, "\'"), "[.]", inputCopy.ptr - input.ptr);
4028                 }
4029             }
4030             else
4031             {
4032                 string inputCopyNext = inputCopy;
4033                 import std.utf;
4034 
4035                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
4036 
4037                 {
4038                     if (foundSymbol != SymbolID.max)
4039                         goto lexerend;
4040                     else
4041                         throw lexerException(text("Error unexpected \'", currentDchar, "\'"), "[.]", inputCopy.ptr - input.ptr);
4042                 }
4043             }
4044         }
4045 
4046     state91:
4047         // "..."
4048         // path: [.] [.] [.]
4049         {
4050             if (inputCopy.length == 0)
4051                 goto endstate91;
4052             goto endstate91;
4053         }
4054         endstate91:
4055         {
4056             assert(inputCopy.ptr >= input.ptr);
4057             foundSymbol = tokenID!"\"...\"";
4058             foundLength = inputCopy.ptr - input.ptr;
4059             foundIsIgnore = false;
4060             goto lexerend;
4061         }
4062 
4063     state92:
4064         // "@"
4065         // path: [@]
4066         {
4067             if (inputCopy.length == 0)
4068                 goto endstate92;
4069             goto endstate92;
4070         }
4071         endstate92:
4072         {
4073             assert(inputCopy.ptr >= input.ptr);
4074             foundSymbol = tokenID!"\"@\"";
4075             foundLength = inputCopy.ptr - input.ptr;
4076             foundIsIgnore = false;
4077             goto lexerend;
4078         }
4079 
4080     state93:
4081         // ":"
4082         // path: [:]
4083         {
4084             if (inputCopy.length == 0)
4085                 goto endstate93;
4086             goto endstate93;
4087         }
4088         endstate93:
4089         {
4090             assert(inputCopy.ptr >= input.ptr);
4091             foundSymbol = tokenID!"\":\"";
4092             foundLength = inputCopy.ptr - input.ptr;
4093             foundIsIgnore = false;
4094             goto lexerend;
4095         }
4096 
4097     state94:
4098         // "{"
4099         // path: [{]
4100         {
4101             if (inputCopy.length == 0)
4102                 goto endstate94;
4103             goto endstate94;
4104         }
4105         endstate94:
4106         {
4107             assert(inputCopy.ptr >= input.ptr);
4108             foundSymbol = tokenID!"\"{\"";
4109             foundLength = inputCopy.ptr - input.ptr;
4110             foundIsIgnore = false;
4111             goto lexerend;
4112         }
4113 
4114     state95:
4115         // "}"
4116         // path: [}]
4117         {
4118             if (inputCopy.length == 0)
4119                 goto endstate95;
4120             goto endstate95;
4121         }
4122         endstate95:
4123         {
4124             assert(inputCopy.ptr >= input.ptr);
4125             foundSymbol = tokenID!"\"}\"";
4126             foundLength = inputCopy.ptr - input.ptr;
4127             foundIsIgnore = false;
4128             goto lexerend;
4129         }
4130 
4131     state96:
4132         // "?"
4133         // path: [?]
4134         {
4135             if (inputCopy.length == 0)
4136                 goto endstate96;
4137             goto endstate96;
4138         }
4139         endstate96:
4140         {
4141             assert(inputCopy.ptr >= input.ptr);
4142             foundSymbol = tokenID!"\"?\"";
4143             foundLength = inputCopy.ptr - input.ptr;
4144             foundIsIgnore = false;
4145             goto lexerend;
4146         }
4147 
4148     state97:
4149         // "!"
4150         // path: [!]
4151         {
4152             if (inputCopy.length == 0)
4153                 goto endstate97;
4154             goto endstate97;
4155         }
4156         endstate97:
4157         {
4158             assert(inputCopy.ptr >= input.ptr);
4159             foundSymbol = tokenID!"\"!\"";
4160             foundLength = inputCopy.ptr - input.ptr;
4161             foundIsIgnore = false;
4162             goto lexerend;
4163         }
4164 
4165     state98:
4166         // "<" ("<<")
4167         // path: [<]
4168         {
4169             if (inputCopy.length == 0)
4170                 goto endstate98;
4171             char currentChar = inputCopy[0];
4172             if (currentChar < 0x80)
4173             {
4174                 if (currentChar == '<')
4175                 {
4176                     assert(inputCopy.ptr >= input.ptr);
4177                     foundSymbol = tokenID!"\"<\"";
4178                     foundLength = inputCopy.ptr - input.ptr;
4179                     foundIsIgnore = false;
4180                     inputCopy = inputCopy[1 .. $];
4181                     goto state99;
4182                 }
4183                 else
4184                 {
4185                     goto endstate98;
4186                 }
4187             }
4188             else
4189             {
4190                 string inputCopyNext = inputCopy;
4191                 import std.utf;
4192 
4193                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
4194 
4195                 {
4196                     goto endstate98;
4197                 }
4198             }
4199         }
4200         endstate98:
4201         {
4202             assert(inputCopy.ptr >= input.ptr);
4203             foundSymbol = tokenID!"\"<\"";
4204             foundLength = inputCopy.ptr - input.ptr;
4205             foundIsIgnore = false;
4206             goto lexerend;
4207         }
4208 
4209     state99:
4210         // "<<"
4211         // path: [<] [<]
4212         {
4213             if (inputCopy.length == 0)
4214                 goto endstate99;
4215             goto endstate99;
4216         }
4217         endstate99:
4218         {
4219             assert(inputCopy.ptr >= input.ptr);
4220             foundSymbol = tokenID!"\"<<\"";
4221             foundLength = inputCopy.ptr - input.ptr;
4222             foundIsIgnore = false;
4223             goto lexerend;
4224         }
4225 
4226     state100:
4227         // ">" (">>")
4228         // path: [>]
4229         {
4230             if (inputCopy.length == 0)
4231                 goto endstate100;
4232             char currentChar = inputCopy[0];
4233             if (currentChar < 0x80)
4234             {
4235                 if (currentChar == '>')
4236                 {
4237                     assert(inputCopy.ptr >= input.ptr);
4238                     foundSymbol = tokenID!"\">\"";
4239                     foundLength = inputCopy.ptr - input.ptr;
4240                     foundIsIgnore = false;
4241                     inputCopy = inputCopy[1 .. $];
4242                     goto state101;
4243                 }
4244                 else
4245                 {
4246                     goto endstate100;
4247                 }
4248             }
4249             else
4250             {
4251                 string inputCopyNext = inputCopy;
4252                 import std.utf;
4253 
4254                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
4255 
4256                 {
4257                     goto endstate100;
4258                 }
4259             }
4260         }
4261         endstate100:
4262         {
4263             assert(inputCopy.ptr >= input.ptr);
4264             foundSymbol = tokenID!"\">\"";
4265             foundLength = inputCopy.ptr - input.ptr;
4266             foundIsIgnore = false;
4267             goto lexerend;
4268         }
4269 
4270     state101:
4271         // ">>"
4272         // path: [>] [>]
4273         {
4274             if (inputCopy.length == 0)
4275                 goto endstate101;
4276             goto endstate101;
4277         }
4278         endstate101:
4279         {
4280             assert(inputCopy.ptr >= input.ptr);
4281             foundSymbol = tokenID!"\">>\"";
4282             foundLength = inputCopy.ptr - input.ptr;
4283             foundIsIgnore = false;
4284             goto lexerend;
4285         }
4286 
4287     state102:
4288         // "*"
4289         // path: [*]
4290         {
4291             if (inputCopy.length == 0)
4292                 goto endstate102;
4293             goto endstate102;
4294         }
4295         endstate102:
4296         {
4297             assert(inputCopy.ptr >= input.ptr);
4298             foundSymbol = tokenID!"\"*\"";
4299             foundLength = inputCopy.ptr - input.ptr;
4300             foundIsIgnore = false;
4301             goto lexerend;
4302         }
4303 
4304     state103:
4305         // "-"
4306         // path: [\-]
4307         {
4308             if (inputCopy.length == 0)
4309                 goto endstate103;
4310             goto endstate103;
4311         }
4312         endstate103:
4313         {
4314             assert(inputCopy.ptr >= input.ptr);
4315             foundSymbol = tokenID!"\"-\"";
4316             foundLength = inputCopy.ptr - input.ptr;
4317             foundIsIgnore = false;
4318             goto lexerend;
4319         }
4320 
4321     state104:
4322         // "|"
4323         // path: [|]
4324         {
4325             if (inputCopy.length == 0)
4326                 goto endstate104;
4327             goto endstate104;
4328         }
4329         endstate104:
4330         {
4331             assert(inputCopy.ptr >= input.ptr);
4332             foundSymbol = tokenID!"\"|\"";
4333             foundLength = inputCopy.ptr - input.ptr;
4334             foundIsIgnore = false;
4335             goto lexerend;
4336         }
4337 
4338     state105:
4339         // "^"
4340         // path: [\^]
4341         {
4342             if (inputCopy.length == 0)
4343                 goto endstate105;
4344             goto endstate105;
4345         }
4346         endstate105:
4347         {
4348             assert(inputCopy.ptr >= input.ptr);
4349             foundSymbol = tokenID!"\"^\"";
4350             foundLength = inputCopy.ptr - input.ptr;
4351             foundIsIgnore = false;
4352             goto lexerend;
4353         }
4354 
4355     state106:
4356         // "+"
4357         // path: [+]
4358         {
4359             if (inputCopy.length == 0)
4360                 goto endstate106;
4361             goto endstate106;
4362         }
4363         endstate106:
4364         {
4365             assert(inputCopy.ptr >= input.ptr);
4366             foundSymbol = tokenID!"\"+\"";
4367             foundLength = inputCopy.ptr - input.ptr;
4368             foundIsIgnore = false;
4369             goto lexerend;
4370         }
4371 
4372         lexerend:
4373 
4374         if (foundSymbol != SymbolID.max)
4375         {
4376             if (foundLength == 0)
4377             {
4378                 if (!inputCopy.empty)
4379                     throw lexerException("no token", null, inputCopy.ptr + 1 - input.ptr);
4380                 else
4381                 {
4382                     front.content = "";
4383                     front.symbol = SymbolID(0);
4384                     static if (includeIgnoredTokens)
4385                         front.isIgnoreToken = false;
4386                     empty = true;
4387                     return;
4388                 }
4389             }
4390             static if (!includeIgnoredTokens)
4391             {
4392                 if (foundIsIgnore)
4393                 {
4394                     front.currentLocation = front.currentLocation + LocationDiff.fromStr(input[0 .. foundLength]);
4395                     input = input[foundLength .. $];
4396                     inputCopy = input;
4397                     foundLength = 0;
4398                     foundIsIgnore = false;
4399                     foundSymbol = SymbolID.max;
4400                     storedStart = size_t.max;
4401                     storedString = null;
4402                     goto start;
4403                 }
4404             }
4405             front.content = input[0 .. foundLength];
4406             front.symbol = foundSymbol;
4407             static if (includeIgnoredTokens)
4408                 front.isIgnoreToken = foundIsIgnore;
4409             empty = false;
4410             return;
4411         }
4412         else if (input.length == 0)
4413         {
4414             front.content = "";
4415             front.symbol = SymbolID(0);
4416             static if (includeIgnoredTokens)
4417                 front.isIgnoreToken = false;
4418             empty = true;
4419             return;
4420         }
4421         else
4422             throw lexerException("no token", null, 1);
4423     }
4424 
4425     // NestingBlockCommentPart* "+"* "+/"
4426     private bool lexPart0(ref string inputCopy, bool hasPreviousSymbol)
4427     {
4428     state0:
4429         // ($m_0)
4430         // path:
4431     start:
4432         {
4433             if (inputCopy.length == 0)
4434             {
4435                 if (input.ptr == inputCopy.ptr)
4436                     return false;
4437                 else if (hasPreviousSymbol)
4438                     return false;
4439                 else
4440                     throw lexerException("EOF", "[^]", inputCopy.ptr - input.ptr);
4441             }
4442             char currentChar = inputCopy[0];
4443             if (currentChar < 0x80)
4444             {
4445                 if (currentChar == '+')
4446                 {
4447                     inputCopy = inputCopy[1 .. $];
4448                     goto state1;
4449                 }
4450                 else if (currentChar == '/')
4451                 {
4452                     inputCopy = inputCopy[1 .. $];
4453                     goto state3;
4454                 }
4455                 else
4456                 {
4457                     inputCopy = inputCopy[1 .. $];
4458                     goto state0;
4459                 }
4460             }
4461             else
4462             {
4463                 string inputCopyNext = inputCopy;
4464                 import std.utf;
4465 
4466                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
4467 
4468                 {
4469                     inputCopy = inputCopyNext;
4470                     goto state0;
4471                 }
4472             }
4473         }
4474 
4475     state1:
4476         // ($m_0)
4477         // path: [+]
4478         {
4479             if (inputCopy.length == 0)
4480             {
4481                 if (input.ptr == inputCopy.ptr)
4482                     return false;
4483                 else if (hasPreviousSymbol)
4484                     return false;
4485                 else
4486                     throw lexerException("EOF", "[^]", inputCopy.ptr - input.ptr);
4487             }
4488             char currentChar = inputCopy[0];
4489             if (currentChar < 0x80)
4490             {
4491                 if (currentChar == '+')
4492                 {
4493                     inputCopy = inputCopy[1 .. $];
4494                     goto state1;
4495                 }
4496                 else if (currentChar == '/')
4497                 {
4498                     inputCopy = inputCopy[1 .. $];
4499                     goto state2;
4500                 }
4501                 else
4502                 {
4503                     inputCopy = inputCopy[1 .. $];
4504                     goto state0;
4505                 }
4506             }
4507             else
4508             {
4509                 string inputCopyNext = inputCopy;
4510                 import std.utf;
4511 
4512                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
4513 
4514                 {
4515                     inputCopy = inputCopyNext;
4516                     goto state0;
4517                 }
4518             }
4519         }
4520 
4521     state2:
4522         // $m_0
4523         // path: [+] [/]
4524         {
4525             if (inputCopy.length == 0)
4526                 return true;
4527             return true;
4528         }
4529         endstate2:
4530 
4531     state3:
4532         // ($m_0)
4533         // path: [/]
4534         {
4535             if (inputCopy.length == 0)
4536             {
4537                 if (input.ptr == inputCopy.ptr)
4538                     return false;
4539                 else if (hasPreviousSymbol)
4540                     return false;
4541                 else
4542                     throw lexerException("EOF", "[^]", inputCopy.ptr - input.ptr);
4543             }
4544             char currentChar = inputCopy[0];
4545             if (currentChar < 0x80)
4546             {
4547                 if (currentChar == '+')
4548                 {
4549                     inputCopy = inputCopy[1 .. $];
4550                     goto state4;
4551                 }
4552                 else if (currentChar == '/')
4553                 {
4554                     inputCopy = inputCopy[1 .. $];
4555                     goto state3;
4556                 }
4557                 else
4558                 {
4559                     inputCopy = inputCopy[1 .. $];
4560                     goto state0;
4561                 }
4562             }
4563             else
4564             {
4565                 string inputCopyNext = inputCopy;
4566                 import std.utf;
4567 
4568                 dchar currentDchar = decodeFront!(Yes.useReplacementDchar)(inputCopyNext);
4569 
4570                 {
4571                     inputCopy = inputCopyNext;
4572                     goto state0;
4573                 }
4574             }
4575         }
4576 
4577     state4:
4578         // ($m_0)
4579         // path: [/] [+]
4580         {
4581             // RecursiveLexer
4582             if (lexPart0(inputCopy, hasPreviousSymbol))
4583                 goto state0;
4584             else
4585                 return false;
4586         }
4587 
4588         assert(false);
4589     }
4590 
4591     SingleParseException!Location lexerException(string errorText, string expected, size_t len,
4592             string file = __FILE__, size_t line = __LINE__)
4593     {
4594         string str = errorText;
4595         if (expected.length)
4596             str ~= ", expected " ~ expected;
4597         return new SingleParseException!Location(str, front.currentLocation, front.currentLocation, file, line);
4598     }
4599 }
4600 
4601 immutable allNonterminalTokens = [
4602     /* 0: */ immutable(Nonterminal)("$null", NonterminalFlags.none, [], []),
4603     /* 1: */ immutable(Nonterminal)("Identifier", NonterminalFlags.none, ["lowPrio"], []),
4604     /* 2: */ immutable(Nonterminal)("StringLiteral", NonterminalFlags.none, [], []),
4605     /* 3: */ immutable(Nonterminal)("CharacterSetLiteral", NonterminalFlags.none, [], []),
4606     /* 4: */ immutable(Nonterminal)("IntegerLiteral", NonterminalFlags.none, [], []),
4607     /* 5: */ immutable(Nonterminal)("\";\"", NonterminalFlags.none, [], []),
4608     /* 6: */ immutable(Nonterminal)("\"=\"", NonterminalFlags.none, [], []),
4609     /* 7: */ immutable(Nonterminal)("\"fragment\"", NonterminalFlags.none, [], []),
4610     /* 8: */ immutable(Nonterminal)("\"token\"", NonterminalFlags.none, [], []),
4611     /* 9: */ immutable(Nonterminal)("\"(\"", NonterminalFlags.none, [], []),
4612     /* 10: */ immutable(Nonterminal)("\")\"", NonterminalFlags.none, [], []),
4613     /* 11: */ immutable(Nonterminal)("\",\"", NonterminalFlags.none, [], []),
4614     /* 12: */ immutable(Nonterminal)("\"...\"", NonterminalFlags.none, [], []),
4615     /* 13: */ immutable(Nonterminal)("\"option\"", NonterminalFlags.none, [], []),
4616     /* 14: */ immutable(Nonterminal)("\"import\"", NonterminalFlags.none, [], []),
4617     /* 15: */ immutable(Nonterminal)("\"match\"", NonterminalFlags.none, [], []),
4618     /* 16: */ immutable(Nonterminal)("\"@\"", NonterminalFlags.none, [], []),
4619     /* 17: */ immutable(Nonterminal)("\":\"", NonterminalFlags.none, [], []),
4620     /* 18: */ immutable(Nonterminal)("\"{\"", NonterminalFlags.none, [], []),
4621     /* 19: */ immutable(Nonterminal)("\"}\"", NonterminalFlags.none, [], []),
4622     /* 20: */ immutable(Nonterminal)("\"?\"", NonterminalFlags.none, [], []),
4623     /* 21: */ immutable(Nonterminal)("\"!\"", NonterminalFlags.none, [], []),
4624     /* 22: */ immutable(Nonterminal)("\"<\"", NonterminalFlags.none, [], []),
4625     /* 23: */ immutable(Nonterminal)("\">\"", NonterminalFlags.none, [], []),
4626     /* 24: */ immutable(Nonterminal)("\"*\"", NonterminalFlags.none, [], []),
4627     /* 25: */ immutable(Nonterminal)("\">>\"", NonterminalFlags.none, [], []),
4628     /* 26: */ immutable(Nonterminal)("\"<<\"", NonterminalFlags.none, [], []),
4629     /* 27: */ immutable(Nonterminal)("\"-\"", NonterminalFlags.none, [], []),
4630     /* 28: */ immutable(Nonterminal)("\"anytoken\"", NonterminalFlags.none, [], []),
4631     /* 29: */ immutable(Nonterminal)("\"|\"", NonterminalFlags.none, [], []),
4632     /* 30: */ immutable(Nonterminal)("\"^\"", NonterminalFlags.none, [], []),
4633     /* 31: */ immutable(Nonterminal)("\"+\"", NonterminalFlags.none, [], []),
4634     /* 32: */ immutable(Nonterminal)("\"t(\"", NonterminalFlags.none, [], []),
4635     /* 33: */ immutable(Nonterminal)("StringPart", NonterminalFlags.none, [], []),
4636     /* 34: */ immutable(Nonterminal)("CharacterSetPart", NonterminalFlags.none, [], []),
4637     /* 35: */ immutable(Nonterminal)("CharacterSetPart2", NonterminalFlags.none, [], []),
4638     /* 36: */ immutable(Nonterminal)("EscapeSequence", NonterminalFlags.none, [], []),
4639     /* 37: */ immutable(Nonterminal)("Hex", NonterminalFlags.none, [], []),
4640     /* 38: */ immutable(Nonterminal)("Space", NonterminalFlags.none, ["ignoreToken"], []),
4641     /* 39: */ immutable(Nonterminal)("LineComment", NonterminalFlags.none, ["ignoreToken"], []),
4642     /* 40: */ immutable(Nonterminal)("BlockComment", NonterminalFlags.none, ["ignoreToken"], []),
4643     /* 41: */ immutable(Nonterminal)("BlockCommentPart", NonterminalFlags.none, [], []),
4644     /* 42: */ immutable(Nonterminal)("NestingBlockComment", NonterminalFlags.none, ["ignoreToken"], []),
4645     /* 43: */ immutable(Nonterminal)("NestingBlockCommentPart", NonterminalFlags.none, [], []),
4646     /* 44: */ immutable(Nonterminal)("[a-zA-Z0-9_]+", NonterminalFlags.none, ["array"], []),
4647     /* 45: */ immutable(Nonterminal)("[a-zA-Z0-9_]*", NonterminalFlags.none, ["array"], []),
4648     /* 46: */ immutable(Nonterminal)("StringPart+", NonterminalFlags.none, ["array"], []),
4649     /* 47: */ immutable(Nonterminal)("StringPart*", NonterminalFlags.none, ["array"], []),
4650     /* 48: */ immutable(Nonterminal)("\"^\"?", NonterminalFlags.none, [], []),
4651     /* 49: */ immutable(Nonterminal)("CharacterSetPart+", NonterminalFlags.none, ["array"], []),
4652     /* 50: */ immutable(Nonterminal)("CharacterSetPart*", NonterminalFlags.none, ["array"], []),
4653     /* 51: */ immutable(Nonterminal)("[0-9]+", NonterminalFlags.none, ["array"], []),
4654     /* 52: */ immutable(Nonterminal)("[0-9]*", NonterminalFlags.none, ["array"], []),
4655     /* 53: */ immutable(Nonterminal)("[_\\n\\r\\t]+", NonterminalFlags.none, ["array"], []),
4656     /* 54: */ immutable(Nonterminal)("[^\\n\\r]+", NonterminalFlags.none, ["array"], []),
4657     /* 55: */ immutable(Nonterminal)("[^\\n\\r]*", NonterminalFlags.none, ["array"], []),
4658     /* 56: */ immutable(Nonterminal)("BlockCommentPart+", NonterminalFlags.none, ["array"], []),
4659     /* 57: */ immutable(Nonterminal)("BlockCommentPart*", NonterminalFlags.none, ["array"], []),
4660     /* 58: */ immutable(Nonterminal)("\"*\"+", NonterminalFlags.none, ["array"], []),
4661     /* 59: */ immutable(Nonterminal)("\"*\"*", NonterminalFlags.none, ["array"], []),
4662     /* 60: */ immutable(Nonterminal)("NestingBlockCommentPart+", NonterminalFlags.none, ["array"], []),
4663     /* 61: */ immutable(Nonterminal)("NestingBlockCommentPart*", NonterminalFlags.none, ["array"], []),
4664     /* 62: */ immutable(Nonterminal)("\"+\"+", NonterminalFlags.none, ["array"], []),
4665     /* 63: */ immutable(Nonterminal)("\"+\"*", NonterminalFlags.none, ["array"], []),
4666     /* 64: */ immutable(Nonterminal)("\"/\"+", NonterminalFlags.none, ["array"], []),
4667     /* 65: */ immutable(Nonterminal)("\"/\"*", NonterminalFlags.none, ["array"], []),
4668 ];