6e7bd74b9fecb5c6d10310cd22173408bbf06fa8
[scilab.git] / scilab / modules / scinotes / src / java / org / scilab / modules / scinotes / MatchingBlockScanner.java
1 /* The following code was generated by JFlex 1.4.3 on 23/05/12 15:23 */
2
3 //CHECKSTYLE:OFF
4
5 package org.scilab.modules.scinotes;
6
7 import java.io.IOException;
8 import javax.swing.text.Element;
9
10 @javax.annotation.Generated("JFlex")
11 @SuppressWarnings("fallthrough")
12
13 /**
14  * This class is a scanner generated by
15  * <a href="http://www.jflex.de/">JFlex</a> 1.4.3
16  * on 23/05/12 15:23 from the specification file
17  * <tt>./jflex/matchingblock.jflex</tt>
18  */
19 public final class MatchingBlockScanner {
20
21     /** This character denotes the end of file */
22     public static final int YYEOF = -1;
23
24     /** initial size of the lookahead buffer */
25     private static final int ZZ_BUFFERSIZE = 256;
26
27     /** lexical states */
28     public static final int OPENCLOSE = 6;
29     public static final int LR = 2;
30     public static final int YYINITIAL = 0;
31     public static final int PSNART = 10;
32     public static final int CLOSEOPEN = 8;
33     public static final int SPEC = 12;
34     public static final int RL = 4;
35
36     /**
37      * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
38      * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
39      *                  at the beginning of a line
40      * l is of the form l = 2*k, k a non negative integer
41      */
42     private static final int ZZ_LEXSTATE[] = {
43         0,  0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6, 6
44     };
45
46     /**
47      * Translates characters to character classes
48      */
49     private static final String ZZ_CMAP_PACKED =
50         "\12\0\1\1\2\0\1\3\23\0\1\6\1\10\1\6\1\4\1\5" +
51         "\1\0\1\7\1\30\1\11\5\0\1\2\12\4\5\0\1\6\1\0" +
52         "\32\6\1\30\1\0\1\11\1\0\1\6\1\0\2\6\1\23\1\31" +
53         "\1\21\1\13\1\6\1\17\1\12\2\6\1\20\1\6\1\27\1\14" +
54         "\2\6\1\15\1\22\1\24\1\26\1\6\1\16\1\6\1\25\1\6" +
55         "\1\30\1\0\1\11\uff82\0";
56
57     /**
58      * Translates characters to character classes
59      */
60     private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
61
62     /**
63      * Translates DFA states to action switch labels.
64      */
65     private static final int [] ZZ_ACTION = zzUnpackAction();
66
67     private static final String ZZ_ACTION_PACKED_0 =
68         "\7\0\6\1\1\2\6\1\1\3\2\1\1\4\6\1" +
69         "\1\2\1\1\11\2\1\5\1\6\1\0\1\7\2\0" +
70         "\1\1\1\3\6\1\11\0\1\2\6\0\1\3\13\0" +
71         "\2\1\1\2\2\1\6\0\1\1\1\2\3\0\1\2" +
72         "\7\0\5\1\11\0\1\3\4\0\3\1\13\0\2\1" +
73         "\7\0\2\1\6\0\1\1\1\0\1\2\3\0\3\1" +
74         "\3\0\1\1\2\0\1\2";
75
76     private static int [] zzUnpackAction() {
77         int [] result = new int[173];
78         int offset = 0;
79         offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
80         return result;
81     }
82
83     private static int zzUnpackAction(String packed, int offset, int [] result) {
84         int i = 0;       /* index in packed string  */
85         int j = offset;  /* index in unpacked array */
86         int l = packed.length();
87         while (i < l) {
88             int count = packed.charAt(i++);
89             int value = packed.charAt(i++);
90             do {
91                 result[j++] = value;
92             } while (--count > 0);
93         }
94         return j;
95     }
96
97
98     /* error codes */
99     private static final int ZZ_UNKNOWN_ERROR = 0;
100     private static final int ZZ_NO_MATCH = 1;
101     private static final int ZZ_PUSHBACK_2BIG = 2;
102
103     /* error messages for the codes above */
104     private static final String ZZ_ERROR_MSG[] = {
105         "Unkown internal scanner error",
106         "Error: could not match input",
107         "Error: pushback value was too large"
108     };
109
110     /** the input device */
111     private java.io.Reader zzReader;
112
113     /** the current state of the DFA */
114     private int zzState;
115
116     /** the current lexical state */
117     private int zzLexicalState = YYINITIAL;
118
119     /** this buffer contains the current text to be matched and is
120         the source of the yytext() string */
121     private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
122
123     /** the textposition at the last accepting state */
124     private int zzMarkedPos;
125
126     /** the current text position in the buffer */
127     private int zzCurrentPos;
128
129     /** startRead marks the beginning of the yytext() string in the buffer */
130     private int zzStartRead;
131
132     /** endRead marks the last character in the buffer, that has been read
133         from input */
134     private int zzEndRead;
135
136     /** number of newlines encountered up to the start of the matched text */
137     private int yyline;
138
139     /** the number of characters up to the start of the matched text */
140     private int yychar;
141
142     /**
143      * the number of characters from the last newline up to the start of the
144      * matched text
145      */
146     private int yycolumn;
147
148     /**
149      * zzAtBOL == true <=> the scanner is currently at the beginning of a line
150      */
151     private boolean zzAtBOL = true;
152
153     /** zzAtEOF == true <=> the scanner is at the EOF */
154     private boolean zzAtEOF;
155
156     /** denotes if the user-EOF-code has already been executed */
157     private boolean zzEOFDone;
158
159     /* user code: */
160     private ScilabDocument doc;
161     private Element elem;
162     private boolean transp = false;
163     private ScilabLexer scilabLexer;
164     private int start;
165     private int end;
166     private int savePos;
167
168     public MatchingBlockScanner(ScilabDocument doc) {
169         this.doc = doc;
170         this.elem = doc.getDefaultRootElement();
171         this.scilabLexer = doc.createLexer();
172     }
173
174     public MatchingPositions getMatchingBlock(int pos, boolean lr) {
175         int p1, s = 1;
176         transp = false;
177         try {
178             if (lr) {
179                 start =  pos;
180                 end = doc.getEndPosition().getOffset();
181                 yyreset(new ScilabDocumentReader(doc, start, end));
182                 yybegin(OPENCLOSE);
183                 if (yylex() != 1) {
184                     return null;
185                 }
186
187                 p1 = pos + yylength();
188                 yybegin(LR);
189             } else {
190                 start = pos - 1;
191                 end = 0;
192                 yyreset(new ScilabDocumentReader(doc, true, start, end));
193                 yybegin(CLOSEOPEN);
194                 if (yylex() != 1) {
195                     return null;
196                 }
197                 p1 = pos - yylength();
198                 yybegin(RL);
199             }
200
201             do {
202                 if (yylex() == 0) {
203                     s--;
204                 } else {
205                     s++;
206                 }
207             } while (zzMarkedPos != 0 && s != 0);
208         } catch (IOException e) {
209             return null;
210         }
211         if (s == 0) {
212             if (lr) {
213                 return new MatchingPositions(pos, p1, pos + yychar, pos + yychar + (transp ? (yylength() - 1) : yylength()));
214             } else {
215                 return new MatchingPositions(p1, pos, pos - yychar - yylength(), pos - yychar);
216             }
217         }
218
219         return null;
220     }
221
222     public final class MatchingPositions {
223         public int firstB;
224         public int firstE;
225         public int secondB;
226         public int secondE;
227
228         private MatchingPositions(int x1, int x2, int y1, int y2) {
229             firstB = x1;
230             firstE = x2;
231             secondB = y1;
232             secondE = y2;
233         }
234     }
235
236
237     /**
238      * Creates a new scanner
239      * There is also a java.io.InputStream version of this constructor.
240      *
241      * @param   in  the java.io.Reader to read input from.
242      */
243     public MatchingBlockScanner(java.io.Reader in) {
244         this.zzReader = in;
245     }
246
247     /**
248      * Creates a new scanner.
249      * There is also java.io.Reader version of this constructor.
250      *
251      * @param   in  the java.io.Inputstream to read input from.
252      */
253     public MatchingBlockScanner(java.io.InputStream in) {
254         this(new java.io.InputStreamReader(in));
255     }
256
257     /**
258      * Unpacks the compressed character translation table.
259      *
260      * @param packed   the packed character translation table
261      * @return         the unpacked character translation table
262      */
263     private static char [] zzUnpackCMap(String packed) {
264         char [] map = new char[0x10000];
265         int i = 0;  /* index in packed string  */
266         int j = 0;  /* index in unpacked array */
267         while (i < 108) {
268             int  count = packed.charAt(i++);
269             char value = packed.charAt(i++);
270             do {
271                 map[j++] = value;
272             } while (--count > 0);
273         }
274         return map;
275     }
276
277
278     /**
279      * Refills the input buffer.
280      *
281      * @return      <code>false</code>, iff there was new input.
282      *
283      * @exception   java.io.IOException  if any I/O-Error occurs
284      */
285     private boolean zzRefill() throws java.io.IOException {
286
287         /* first: make room (if you can) */
288         if (zzStartRead > 0) {
289             System.arraycopy(zzBuffer, zzStartRead,
290                              zzBuffer, 0,
291                              zzEndRead - zzStartRead);
292
293             /* translate stored positions */
294             zzEndRead -= zzStartRead;
295             zzCurrentPos -= zzStartRead;
296             zzMarkedPos -= zzStartRead;
297             zzStartRead = 0;
298         }
299
300         /* is the buffer big enough? */
301         if (zzCurrentPos >= zzBuffer.length) {
302             /* if not: blow it up */
303             char newBuffer[] = new char[zzCurrentPos * 2];
304             System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
305             zzBuffer = newBuffer;
306         }
307
308         /* finally: fill the buffer with new input */
309         int numRead = zzReader.read(zzBuffer, zzEndRead,
310                                     zzBuffer.length - zzEndRead);
311
312         if (numRead > 0) {
313             zzEndRead += numRead;
314             return false;
315         }
316         // unlikely but not impossible: read 0 characters, but not at end of stream
317         if (numRead == 0) {
318             int c = zzReader.read();
319             if (c == -1) {
320                 return true;
321             } else {
322                 zzBuffer[zzEndRead++] = (char) c;
323                 return false;
324             }
325         }
326
327         // numRead < 0
328         return true;
329     }
330
331
332     /**
333      * Closes the input stream.
334      */
335     public final void yyclose() throws java.io.IOException {
336         zzAtEOF = true;            /* indicate end of file */
337         zzEndRead = zzStartRead;  /* invalidate buffer    */
338
339         if (zzReader != null) {
340             zzReader.close();
341         }
342     }
343
344
345     /**
346      * Resets the scanner to read from a new input stream.
347      * Does not close the old reader.
348      *
349      * All internal variables are reset, the old input stream
350      * <b>cannot</b> be reused (internal buffer is discarded and lost).
351      * Lexical state is set to <tt>ZZ_INITIAL</tt>.
352      *
353      * @param reader   the new input stream
354      */
355     public final void yyreset(java.io.Reader reader) {
356         zzReader = reader;
357         zzAtBOL  = true;
358         zzAtEOF  = false;
359         zzEOFDone = false;
360         zzEndRead = zzStartRead = 0;
361         zzCurrentPos = zzMarkedPos = 0;
362         yyline = yychar = yycolumn = 0;
363         zzLexicalState = YYINITIAL;
364     }
365
366
367     /**
368      * Returns the current lexical state.
369      */
370     public final int yystate() {
371         return zzLexicalState;
372     }
373
374
375     /**
376      * Enters a new lexical state
377      *
378      * @param newState the new lexical state
379      */
380     public final void yybegin(int newState) {
381         zzLexicalState = newState;
382     }
383
384
385     /**
386      * Returns the text matched by the current regular expression.
387      */
388     public final String yytext() {
389         return new String( zzBuffer, zzStartRead, zzMarkedPos - zzStartRead );
390     }
391
392
393     /**
394      * Returns the character at position <tt>pos</tt> from the
395      * matched text.
396      *
397      * It is equivalent to yytext().charAt(pos), but faster
398      *
399      * @param pos the position of the character to fetch.
400      *            A value from 0 to yylength()-1.
401      *
402      * @return the character at position pos
403      */
404     public final char yycharat(int pos) {
405         return zzBuffer[zzStartRead + pos];
406     }
407
408
409     /**
410      * Returns the length of the matched text region.
411      */
412     public final int yylength() {
413         return zzMarkedPos - zzStartRead;
414     }
415
416
417     /**
418      * Reports an error that occurred while scanning.
419      *
420      * In a wellformed scanner (no or only correct usage of
421      * yypushback(int) and a match-all fallback rule) this method
422      * will only be called with things that "Can't Possibly Happen".
423      * If this method is called, something is seriously wrong
424      * (e.g. a JFlex bug producing a faulty scanner etc.).
425      *
426      * Usual syntax/scanner level error handling should be done
427      * in error fallback rules.
428      *
429      * @param   errorCode  the code of the errormessage to display
430      */
431     private void zzScanError(int errorCode) {
432         String message;
433         try {
434             message = ZZ_ERROR_MSG[errorCode];
435         } catch (ArrayIndexOutOfBoundsException e) {
436             message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
437         }
438
439         throw new Error(message);
440     }
441
442
443     /**
444      * Pushes the specified amount of characters back into the input stream.
445      *
446      * They will be read again by then next call of the scanning method
447      *
448      * @param number  the number of characters to be read again.
449      *                This number must not be greater than yylength()!
450      */
451     public void yypushback(int number)  {
452         if ( number > yylength() ) {
453             zzScanError(ZZ_PUSHBACK_2BIG);
454         }
455
456         zzMarkedPos -= number;
457     }
458
459
460     /**
461      * Resumes scanning until the next regular expression is matched,
462      * the end of input is encountered or an I/O-Error occurs.
463      *
464      * @return      the next token
465      * @exception   java.io.IOException  if any I/O-Error occurs
466      */
467     public int yylex() throws java.io.IOException {
468         int zzInput;
469         int zzAction;
470
471         // cached fields:
472         int zzCurrentPosL;
473         int zzMarkedPosL;
474         int zzEndReadL = zzEndRead;
475         char [] zzBufferL = zzBuffer;
476         char [] zzCMapL = ZZ_CMAP;
477
478
479         while (true) {
480             zzMarkedPosL = zzMarkedPos;
481
482             yychar += zzMarkedPosL - zzStartRead;
483
484             zzAction = -1;
485
486             zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
487
488             zzState = ZZ_LEXSTATE[zzLexicalState];
489
490
491             zzForAction: {
492                 while (true) {
493
494                     if (zzCurrentPosL < zzEndReadL) {
495                         zzInput = zzBufferL[zzCurrentPosL++];
496                     } else if (zzAtEOF) {
497                         zzInput = YYEOF;
498                         break zzForAction;
499                     } else {
500                         // store back cached positions
501                         zzCurrentPos  = zzCurrentPosL;
502                         zzMarkedPos   = zzMarkedPosL;
503                         boolean eof = zzRefill();
504                         // get translated positions and possibly new buffer
505                         zzCurrentPosL  = zzCurrentPos;
506                         zzMarkedPosL   = zzMarkedPos;
507                         zzBufferL      = zzBuffer;
508                         zzEndReadL     = zzEndRead;
509                         if (eof) {
510                             zzInput = YYEOF;
511                             break zzForAction;
512                         } else {
513                             zzInput = zzBufferL[zzCurrentPosL++];
514                         }
515                     }
516                     zzInput = zzCMapL[zzInput];
517
518                     boolean zzIsFinal = false;
519                     boolean zzNoLookAhead = false;
520
521                     zzForNext: {
522                         switch (zzState) {
523                             case 1:
524                                 switch (zzInput) {
525                                     case 0:
526                                     case 1:
527                                     case 3:
528                                         zzIsFinal = true;
529                                         zzNoLookAhead = true;
530                                         zzState = 7;
531                                         break zzForNext;
532                                     case 2:
533                                         zzIsFinal = true;
534                                         zzState = 8;
535                                         break zzForNext;
536                                     case 4:
537                                         zzIsFinal = true;
538                                         zzState = 9;
539                                         break zzForNext;
540                                     case 5:
541                                         zzIsFinal = true;
542                                         zzState = 10;
543                                         break zzForNext;
544                                     case 7:
545                                     case 8:
546                                         zzIsFinal = true;
547                                         zzState = 12;
548                                         break zzForNext;
549                                     case 9:
550                                         zzIsFinal = true;
551                                         zzState = 13;
552                                         break zzForNext;
553                                     case 10:
554                                         zzIsFinal = true;
555                                         zzState = 14;
556                                         break zzForNext;
557                                     case 11:
558                                         zzIsFinal = true;
559                                         zzState = 15;
560                                         break zzForNext;
561                                     case 14:
562                                         zzIsFinal = true;
563                                         zzState = 16;
564                                         break zzForNext;
565                                     case 17:
566                                         zzIsFinal = true;
567                                         zzState = 17;
568                                         break zzForNext;
569                                     case 18:
570                                         zzIsFinal = true;
571                                         zzState = 18;
572                                         break zzForNext;
573                                     case 20:
574                                         zzIsFinal = true;
575                                         zzState = 19;
576                                         break zzForNext;
577                                     case 24:
578                                         zzIsFinal = true;
579                                         zzNoLookAhead = true;
580                                         zzState = 20;
581                                         break zzForNext;
582                                     default:
583                                         zzIsFinal = true;
584                                         zzState = 11;
585                                         break zzForNext;
586                                 }
587
588                             case 2:
589                                 switch (zzInput) {
590                                     case 0:
591                                     case 2:
592                                     case 3:
593                                     case 5:
594                                         zzIsFinal = true;
595                                         zzNoLookAhead = true;
596                                         zzState = 7;
597                                         break zzForNext;
598                                     case 8:
599                                         zzIsFinal = true;
600                                         zzState = 12;
601                                         break zzForNext;
602                                     case 9:
603                                         zzIsFinal = true;
604                                         zzNoLookAhead = true;
605                                         zzState = 20;
606                                         break zzForNext;
607                                     case 1:
608                                         zzIsFinal = true;
609                                         zzState = 21;
610                                         break zzForNext;
611                                     case 7:
612                                         zzIsFinal = true;
613                                         zzNoLookAhead = true;
614                                         zzState = 23;
615                                         break zzForNext;
616                                     case 11:
617                                         zzIsFinal = true;
618                                         zzState = 24;
619                                         break zzForNext;
620                                     case 13:
621                                         zzIsFinal = true;
622                                         zzState = 25;
623                                         break zzForNext;
624                                     case 17:
625                                         zzIsFinal = true;
626                                         zzState = 26;
627                                         break zzForNext;
628                                     case 20:
629                                         zzIsFinal = true;
630                                         zzState = 27;
631                                         break zzForNext;
632                                     case 21:
633                                         zzIsFinal = true;
634                                         zzState = 28;
635                                         break zzForNext;
636                                     case 23:
637                                         zzIsFinal = true;
638                                         zzState = 29;
639                                         break zzForNext;
640                                     case 24:
641                                         zzIsFinal = true;
642                                         zzNoLookAhead = true;
643                                         zzState = 30;
644                                         break zzForNext;
645                                     case 25:
646                                         zzIsFinal = true;
647                                         zzState = 31;
648                                         break zzForNext;
649                                     default:
650                                         zzIsFinal = true;
651                                         zzState = 22;
652                                         break zzForNext;
653                                 }
654
655                             case 3:
656                                 switch (zzInput) {
657                                     case 24:
658                                         zzIsFinal = true;
659                                         zzNoLookAhead = true;
660                                         zzState = 20;
661                                         break zzForNext;
662                                     case 10:
663                                         zzIsFinal = true;
664                                         zzState = 32;
665                                         break zzForNext;
666                                     case 11:
667                                         zzIsFinal = true;
668                                         zzState = 33;
669                                         break zzForNext;
670                                     case 14:
671                                         zzIsFinal = true;
672                                         zzState = 34;
673                                         break zzForNext;
674                                     case 17:
675                                         zzIsFinal = true;
676                                         zzState = 35;
677                                         break zzForNext;
678                                     case 18:
679                                         zzIsFinal = true;
680                                         zzState = 36;
681                                         break zzForNext;
682                                     case 20:
683                                         zzIsFinal = true;
684                                         zzState = 37;
685                                         break zzForNext;
686                                     default:
687                                         zzIsFinal = true;
688                                         zzNoLookAhead = true;
689                                         zzState = 30;
690                                         break zzForNext;
691                                 }
692
693                             case 4:
694                                 switch (zzInput) {
695                                     case 9:
696                                         zzIsFinal = true;
697                                         zzNoLookAhead = true;
698                                         zzState = 20;
699                                         break zzForNext;
700                                     case 0:
701                                     case 1:
702                                     case 2:
703                                     case 3:
704                                     case 5:
705                                     case 7:
706                                     case 8:
707                                     case 24:
708                                         zzIsFinal = true;
709                                         zzNoLookAhead = true;
710                                         zzState = 30;
711                                         break zzForNext;
712                                     case 23:
713                                         zzIsFinal = true;
714                                         zzState = 39;
715                                         break zzForNext;
716                                     case 25:
717                                         zzIsFinal = true;
718                                         zzState = 40;
719                                         break zzForNext;
720                                     default:
721                                         zzIsFinal = true;
722                                         zzState = 38;
723                                         break zzForNext;
724                                 }
725
726                             case 5:
727                                 switch (zzInput) {
728                                     case 7:
729                                         zzIsFinal = true;
730                                         zzNoLookAhead = true;
731                                         zzState = 41;
732                                         break zzForNext;
733                                     default:
734                                         break zzForAction;
735                                 }
736
737                             case 6:
738                                 switch (zzInput) {
739                                     default:
740                                         zzIsFinal = true;
741                                         zzNoLookAhead = true;
742                                         zzState = 42;
743                                         break zzForNext;
744                                 }
745
746                             case 8:
747                                 switch (zzInput) {
748                                     case 2:
749                                         zzState = 43;
750                                         break zzForNext;
751                                     default:
752                                         break zzForAction;
753                                 }
754
755                             case 9:
756                                 switch (zzInput) {
757                                     case 7:
758                                         zzIsFinal = true;
759                                         zzNoLookAhead = true;
760                                         zzState = 44;
761                                         break zzForNext;
762                                     case 17:
763                                         zzState = 45;
764                                         break zzForNext;
765                                     default:
766                                         break zzForAction;
767                                 }
768
769                             case 10:
770                                 switch (zzInput) {
771                                     case 0:
772                                     case 1:
773                                     case 2:
774                                     case 3:
775                                     case 5:
776                                     case 7:
777                                     case 8:
778                                     case 9:
779                                     case 24:
780                                         break zzForAction;
781                                     default:
782                                         zzIsFinal = true;
783                                         break zzForNext;
784                                 }
785
786                             case 11:
787                                 switch (zzInput) {
788                                     case 7:
789                                         zzIsFinal = true;
790                                         zzNoLookAhead = true;
791                                         zzState = 44;
792                                         break zzForNext;
793                                     case 0:
794                                     case 1:
795                                     case 2:
796                                     case 3:
797                                     case 5:
798                                     case 8:
799                                     case 9:
800                                     case 24:
801                                         break zzForAction;
802                                     default:
803                                         zzIsFinal = true;
804                                         zzState = 10;
805                                         break zzForNext;
806                                 }
807
808                             case 12:
809                                 switch (zzInput) {
810                                     case 7:
811                                     case 8:
812                                         zzIsFinal = true;
813                                         zzState = 47;
814                                         break zzForNext;
815                                     case 1:
816                                     case 3:
817                                         break zzForAction;
818                                     default:
819                                         zzState = 46;
820                                         break zzForNext;
821                                 }
822
823                             case 13:
824                                 switch (zzInput) {
825                                     case 7:
826                                         zzIsFinal = true;
827                                         zzNoLookAhead = true;
828                                         zzState = 44;
829                                         break zzForNext;
830                                     default:
831                                         break zzForAction;
832                                 }
833
834                             case 14:
835                                 switch (zzInput) {
836                                     case 7:
837                                         zzIsFinal = true;
838                                         zzNoLookAhead = true;
839                                         zzState = 44;
840                                         break zzForNext;
841                                     case 11:
842                                         zzIsFinal = true;
843                                         zzState = 48;
844                                         break zzForNext;
845                                     case 0:
846                                     case 1:
847                                     case 2:
848                                     case 3:
849                                     case 5:
850                                     case 8:
851                                     case 9:
852                                     case 24:
853                                         break zzForAction;
854                                     default:
855                                         zzIsFinal = true;
856                                         zzState = 10;
857                                         break zzForNext;
858                                 }
859
860                             case 15:
861                                 switch (zzInput) {
862                                     case 7:
863                                         zzIsFinal = true;
864                                         zzNoLookAhead = true;
865                                         zzState = 44;
866                                         break zzForNext;
867                                     case 12:
868                                         zzIsFinal = true;
869                                         zzState = 49;
870                                         break zzForNext;
871                                     case 22:
872                                         zzIsFinal = true;
873                                         zzState = 50;
874                                         break zzForNext;
875                                     case 0:
876                                     case 1:
877                                     case 2:
878                                     case 3:
879                                     case 5:
880                                     case 8:
881                                     case 9:
882                                     case 24:
883                                         break zzForAction;
884                                     default:
885                                         zzIsFinal = true;
886                                         zzState = 10;
887                                         break zzForNext;
888                                 }
889
890                             case 16:
891                                 switch (zzInput) {
892                                     case 7:
893                                         zzIsFinal = true;
894                                         zzNoLookAhead = true;
895                                         zzState = 44;
896                                         break zzForNext;
897                                     case 15:
898                                         zzIsFinal = true;
899                                         zzState = 51;
900                                         break zzForNext;
901                                     case 0:
902                                     case 1:
903                                     case 2:
904                                     case 3:
905                                     case 5:
906                                     case 8:
907                                     case 9:
908                                     case 24:
909                                         break zzForAction;
910                                     default:
911                                         zzIsFinal = true;
912                                         zzState = 10;
913                                         break zzForNext;
914                                 }
915
916                             case 17:
917                                 switch (zzInput) {
918                                     case 7:
919                                         zzIsFinal = true;
920                                         zzNoLookAhead = true;
921                                         zzState = 44;
922                                         break zzForNext;
923                                     case 23:
924                                         zzIsFinal = true;
925                                         zzState = 52;
926                                         break zzForNext;
927                                     case 0:
928                                     case 1:
929                                     case 2:
930                                     case 3:
931                                     case 5:
932                                     case 8:
933                                     case 9:
934                                     case 24:
935                                         break zzForAction;
936                                     default:
937                                         zzIsFinal = true;
938                                         zzState = 10;
939                                         break zzForNext;
940                                 }
941
942                             case 18:
943                                 switch (zzInput) {
944                                     case 7:
945                                         zzIsFinal = true;
946                                         zzNoLookAhead = true;
947                                         zzState = 44;
948                                         break zzForNext;
949                                     case 17:
950                                         zzIsFinal = true;
951                                         zzState = 53;
952                                         break zzForNext;
953                                     case 0:
954                                     case 1:
955                                     case 2:
956                                     case 3:
957                                     case 5:
958                                     case 8:
959                                     case 9:
960                                     case 24:
961                                         break zzForAction;
962                                     default:
963                                         zzIsFinal = true;
964                                         zzState = 10;
965                                         break zzForNext;
966                                 }
967
968                             case 19:
969                                 switch (zzInput) {
970                                     case 7:
971                                         zzIsFinal = true;
972                                         zzNoLookAhead = true;
973                                         zzState = 44;
974                                         break zzForNext;
975                                     case 13:
976                                         zzIsFinal = true;
977                                         zzState = 54;
978                                         break zzForNext;
979                                     case 0:
980                                     case 1:
981                                     case 2:
982                                     case 3:
983                                     case 5:
984                                     case 8:
985                                     case 9:
986                                     case 24:
987                                         break zzForAction;
988                                     default:
989                                         zzIsFinal = true;
990                                         zzState = 10;
991                                         break zzForNext;
992                                 }
993
994                             case 21:
995                                 switch (zzInput) {
996                                     case 2:
997                                         zzState = 56;
998                                         break zzForNext;
999                                     case 1:
1000                                     case 3:
1001                                         break zzForAction;
1002                                     default:
1003                                         zzState = 55;
1004                                         break zzForNext;
1005                                 }
1006
1007                             case 22:
1008                                 switch (zzInput) {
1009                                     case 11:
1010                                         zzState = 57;
1011                                         break zzForNext;
1012                                     case 13:
1013                                         zzState = 58;
1014                                         break zzForNext;
1015                                     case 17:
1016                                         zzState = 59;
1017                                         break zzForNext;
1018                                     case 20:
1019                                         zzState = 60;
1020                                         break zzForNext;
1021                                     case 21:
1022                                         zzState = 61;
1023                                         break zzForNext;
1024                                     case 23:
1025                                         zzState = 62;
1026                                         break zzForNext;
1027                                     case 25:
1028                                         zzState = 63;
1029                                         break zzForNext;
1030                                     default:
1031                                         break zzForAction;
1032                                 }
1033
1034                             case 24:
1035                                 switch (zzInput) {
1036                                     case 11:
1037                                         zzState = 57;
1038                                         break zzForNext;
1039                                     case 13:
1040                                         zzState = 58;
1041                                         break zzForNext;
1042                                     case 17:
1043                                         zzState = 59;
1044                                         break zzForNext;
1045                                     case 20:
1046                                         zzState = 60;
1047                                         break zzForNext;
1048                                     case 21:
1049                                         zzState = 61;
1050                                         break zzForNext;
1051                                     case 23:
1052                                         zzState = 62;
1053                                         break zzForNext;
1054                                     case 25:
1055                                         zzState = 63;
1056                                         break zzForNext;
1057                                     case 10:
1058                                         zzIsFinal = true;
1059                                         zzState = 64;
1060                                         break zzForNext;
1061                                     default:
1062                                         break zzForAction;
1063                                 }
1064
1065                             case 25:
1066                                 switch (zzInput) {
1067                                     case 11:
1068                                         zzState = 57;
1069                                         break zzForNext;
1070                                     case 13:
1071                                         zzState = 58;
1072                                         break zzForNext;
1073                                     case 17:
1074                                         zzState = 59;
1075                                         break zzForNext;
1076                                     case 20:
1077                                         zzState = 60;
1078                                         break zzForNext;
1079                                     case 21:
1080                                         zzState = 61;
1081                                         break zzForNext;
1082                                     case 23:
1083                                         zzState = 62;
1084                                         break zzForNext;
1085                                     case 25:
1086                                         zzState = 63;
1087                                         break zzForNext;
1088                                     case 12:
1089                                         zzState = 65;
1090                                         break zzForNext;
1091                                     default:
1092                                         break zzForAction;
1093                                 }
1094
1095                             case 26:
1096                                 switch (zzInput) {
1097                                     case 11:
1098                                         zzState = 57;
1099                                         break zzForNext;
1100                                     case 13:
1101                                         zzState = 58;
1102                                         break zzForNext;
1103                                     case 17:
1104                                         zzState = 59;
1105                                         break zzForNext;
1106                                     case 20:
1107                                         zzState = 60;
1108                                         break zzForNext;
1109                                     case 21:
1110                                         zzState = 61;
1111                                         break zzForNext;
1112                                     case 23:
1113                                         zzState = 62;
1114                                         break zzForNext;
1115                                     case 25:
1116                                         zzState = 63;
1117                                         break zzForNext;
1118                                     case 16:
1119                                         zzState = 66;
1120                                         break zzForNext;
1121                                     default:
1122                                         break zzForAction;
1123                                 }
1124
1125                             case 27:
1126                                 switch (zzInput) {
1127                                     case 11:
1128                                         zzState = 57;
1129                                         break zzForNext;
1130                                     case 13:
1131                                         zzState = 58;
1132                                         break zzForNext;
1133                                     case 17:
1134                                         zzState = 59;
1135                                         break zzForNext;
1136                                     case 20:
1137                                         zzState = 60;
1138                                         break zzForNext;
1139                                     case 21:
1140                                         zzState = 61;
1141                                         break zzForNext;
1142                                     case 23:
1143                                         zzState = 62;
1144                                         break zzForNext;
1145                                     case 25:
1146                                         zzState = 63;
1147                                         break zzForNext;
1148                                     case 19:
1149                                         zzState = 67;
1150                                         break zzForNext;
1151                                     default:
1152                                         break zzForAction;
1153                                 }
1154
1155                             case 28:
1156                                 switch (zzInput) {
1157                                     case 11:
1158                                         zzState = 57;
1159                                         break zzForNext;
1160                                     case 17:
1161                                         zzState = 59;
1162                                         break zzForNext;
1163                                     case 20:
1164                                         zzState = 60;
1165                                         break zzForNext;
1166                                     case 21:
1167                                         zzState = 61;
1168                                         break zzForNext;
1169                                     case 23:
1170                                         zzState = 62;
1171                                         break zzForNext;
1172                                     case 25:
1173                                         zzState = 63;
1174                                         break zzForNext;
1175                                     case 13:
1176                                         zzState = 68;
1177                                         break zzForNext;
1178                                     default:
1179                                         break zzForAction;
1180                                 }
1181
1182                             case 29:
1183                                 switch (zzInput) {
1184                                     case 11:
1185                                         zzState = 57;
1186                                         break zzForNext;
1187                                     case 13:
1188                                         zzState = 58;
1189                                         break zzForNext;
1190                                     case 17:
1191                                         zzState = 59;
1192                                         break zzForNext;
1193                                     case 20:
1194                                         zzState = 60;
1195                                         break zzForNext;
1196                                     case 21:
1197                                         zzState = 61;
1198                                         break zzForNext;
1199                                     case 23:
1200                                         zzState = 62;
1201                                         break zzForNext;
1202                                     case 25:
1203                                         zzState = 63;
1204                                         break zzForNext;
1205                                     case 12:
1206                                         zzState = 69;
1207                                         break zzForNext;
1208                                     default:
1209                                         break zzForAction;
1210                                 }
1211
1212                             case 31:
1213                                 switch (zzInput) {
1214                                     case 11:
1215                                         zzState = 57;
1216                                         break zzForNext;
1217                                     case 13:
1218                                         zzState = 58;
1219                                         break zzForNext;
1220                                     case 17:
1221                                         zzState = 59;
1222                                         break zzForNext;
1223                                     case 20:
1224                                         zzState = 60;
1225                                         break zzForNext;
1226                                     case 21:
1227                                         zzState = 61;
1228                                         break zzForNext;
1229                                     case 25:
1230                                         zzState = 63;
1231                                         break zzForNext;
1232                                     case 23:
1233                                         zzState = 70;
1234                                         break zzForNext;
1235                                     default:
1236                                         break zzForAction;
1237                                 }
1238
1239                             case 32:
1240                                 switch (zzInput) {
1241                                     case 11:
1242                                         zzIsFinal = true;
1243                                         zzState = 71;
1244                                         break zzForNext;
1245                                     default:
1246                                         break zzForAction;
1247                                 }
1248
1249                             case 33:
1250                                 switch (zzInput) {
1251                                     case 12:
1252                                         zzState = 72;
1253                                         break zzForNext;
1254                                     case 22:
1255                                         zzState = 73;
1256                                         break zzForNext;
1257                                     default:
1258                                         break zzForAction;
1259                                 }
1260
1261                             case 34:
1262                                 switch (zzInput) {
1263                                     case 15:
1264                                         zzState = 74;
1265                                         break zzForNext;
1266                                     default:
1267                                         break zzForAction;
1268                                 }
1269
1270                             case 35:
1271                                 switch (zzInput) {
1272                                     case 16:
1273                                         zzState = 75;
1274                                         break zzForNext;
1275                                     default:
1276                                         break zzForAction;
1277                                 }
1278
1279                             case 36:
1280                                 switch (zzInput) {
1281                                     case 17:
1282                                         zzState = 76;
1283                                         break zzForNext;
1284                                     default:
1285                                         break zzForAction;
1286                                 }
1287
1288                             case 37:
1289                                 switch (zzInput) {
1290                                     case 13:
1291                                         zzState = 77;
1292                                         break zzForNext;
1293                                     default:
1294                                         break zzForAction;
1295                                 }
1296
1297                             case 38:
1298                                 switch (zzInput) {
1299                                     case 23:
1300                                         zzState = 78;
1301                                         break zzForNext;
1302                                     case 25:
1303                                         zzState = 79;
1304                                         break zzForNext;
1305                                     default:
1306                                         break zzForAction;
1307                                 }
1308
1309                             case 39:
1310                                 switch (zzInput) {
1311                                     case 23:
1312                                         zzState = 78;
1313                                         break zzForNext;
1314                                     case 25:
1315                                         zzState = 79;
1316                                         break zzForNext;
1317                                     case 12:
1318                                         zzState = 80;
1319                                         break zzForNext;
1320                                     default:
1321                                         break zzForAction;
1322                                 }
1323
1324                             case 40:
1325                                 switch (zzInput) {
1326                                     case 25:
1327                                         zzState = 79;
1328                                         break zzForNext;
1329                                     case 23:
1330                                         zzState = 81;
1331                                         break zzForNext;
1332                                     default:
1333                                         break zzForAction;
1334                                 }
1335
1336                             case 43:
1337                                 switch (zzInput) {
1338                                     case 1:
1339                                         zzIsFinal = true;
1340                                         zzNoLookAhead = true;
1341                                         zzState = 7;
1342                                         break zzForNext;
1343                                     default:
1344                                         break zzForNext;
1345                                 }
1346
1347                             case 45:
1348                                 switch (zzInput) {
1349                                     case 23:
1350                                         zzState = 82;
1351                                         break zzForNext;
1352                                     default:
1353                                         break zzForAction;
1354                                 }
1355
1356                             case 46:
1357                                 switch (zzInput) {
1358                                     case 7:
1359                                     case 8:
1360                                         zzIsFinal = true;
1361                                         zzState = 47;
1362                                         break zzForNext;
1363                                     case 1:
1364                                     case 3:
1365                                         break zzForAction;
1366                                     default:
1367                                         break zzForNext;
1368                                 }
1369
1370                             case 47:
1371                                 switch (zzInput) {
1372                                     case 7:
1373                                     case 8:
1374                                         zzState = 46;
1375                                         break zzForNext;
1376                                     default:
1377                                         break zzForAction;
1378                                 }
1379
1380                             case 48:
1381                                 switch (zzInput) {
1382                                     case 0:
1383                                     case 1:
1384                                     case 2:
1385                                     case 3:
1386                                     case 5:
1387                                     case 7:
1388                                     case 8:
1389                                     case 9:
1390                                     case 24:
1391                                         break zzForAction;
1392                                     default:
1393                                         zzIsFinal = true;
1394                                         zzState = 10;
1395                                         break zzForNext;
1396                                 }
1397
1398                             case 49:
1399                                 switch (zzInput) {
1400                                     case 13:
1401                                         zzIsFinal = true;
1402                                         zzState = 48;
1403                                         break zzForNext;
1404                                     case 0:
1405                                     case 1:
1406                                     case 2:
1407                                     case 3:
1408                                     case 5:
1409                                     case 7:
1410                                     case 8:
1411                                     case 9:
1412                                     case 24:
1413                                         break zzForAction;
1414                                     default:
1415                                         zzIsFinal = true;
1416                                         zzState = 10;
1417                                         break zzForNext;
1418                                 }
1419
1420                             case 50:
1421                                 switch (zzInput) {
1422                                     case 23:
1423                                         zzIsFinal = true;
1424                                         zzState = 83;
1425                                         break zzForNext;
1426                                     case 0:
1427                                     case 1:
1428                                     case 2:
1429                                     case 3:
1430                                     case 5:
1431                                     case 7:
1432                                     case 8:
1433                                     case 9:
1434                                     case 24:
1435                                         break zzForAction;
1436                                     default:
1437                                         zzIsFinal = true;
1438                                         zzState = 10;
1439                                         break zzForNext;
1440                                 }
1441
1442                             case 51:
1443                                 switch (zzInput) {
1444                                     case 10:
1445                                         zzIsFinal = true;
1446                                         zzState = 84;
1447                                         break zzForNext;
1448                                     case 0:
1449                                     case 1:
1450                                     case 2:
1451                                     case 3:
1452                                     case 5:
1453                                     case 7:
1454                                     case 8:
1455                                     case 9:
1456                                     case 24:
1457                                         break zzForAction;
1458                                     default:
1459                                         zzIsFinal = true;
1460                                         zzState = 10;
1461                                         break zzForNext;
1462                                 }
1463
1464                             case 52:
1465                                 switch (zzInput) {
1466                                     case 25:
1467                                         zzIsFinal = true;
1468                                         zzState = 85;
1469                                         break zzForNext;
1470                                     case 0:
1471                                     case 1:
1472                                     case 2:
1473                                     case 3:
1474                                     case 5:
1475                                     case 7:
1476                                     case 8:
1477                                     case 9:
1478                                     case 24:
1479                                         break zzForAction;
1480                                     default:
1481                                         zzIsFinal = true;
1482                                         zzState = 10;
1483                                         break zzForNext;
1484                                 }
1485
1486                             case 53:
1487                                 switch (zzInput) {
1488                                     case 16:
1489                                         zzIsFinal = true;
1490                                         zzState = 86;
1491                                         break zzForNext;
1492                                     case 0:
1493                                     case 1:
1494                                     case 2:
1495                                     case 3:
1496                                     case 5:
1497                                     case 7:
1498                                     case 8:
1499                                     case 9:
1500                                     case 24:
1501                                         break zzForAction;
1502                                     default:
1503                                         zzIsFinal = true;
1504                                         zzState = 10;
1505                                         break zzForNext;
1506                                 }
1507
1508                             case 54:
1509                                 switch (zzInput) {
1510                                     case 21:
1511                                         zzIsFinal = true;
1512                                         zzState = 48;
1513                                         break zzForNext;
1514                                     case 0:
1515                                     case 1:
1516                                     case 2:
1517                                     case 3:
1518                                     case 5:
1519                                     case 7:
1520                                     case 8:
1521                                     case 9:
1522                                     case 24:
1523                                         break zzForAction;
1524                                     default:
1525                                         zzIsFinal = true;
1526                                         zzState = 10;
1527                                         break zzForNext;
1528                                 }
1529
1530                             case 55:
1531                                 switch (zzInput) {
1532                                     case 2:
1533                                         zzState = 56;
1534                                         break zzForNext;
1535                                     case 1:
1536                                     case 3:
1537                                         break zzForAction;
1538                                     default:
1539                                         break zzForNext;
1540                                 }
1541
1542                             case 56:
1543                                 switch (zzInput) {
1544                                     case 2:
1545                                         zzIsFinal = true;
1546                                         zzState = 87;
1547                                         break zzForNext;
1548                                     case 1:
1549                                     case 3:
1550                                         break zzForAction;
1551                                     default:
1552                                         zzState = 55;
1553                                         break zzForNext;
1554                                 }
1555
1556                             case 57:
1557                                 switch (zzInput) {
1558                                     case 10:
1559                                         zzIsFinal = true;
1560                                         zzNoLookAhead = true;
1561                                         zzState = 7;
1562                                         break zzForNext;
1563                                     default:
1564                                         break zzForAction;
1565                                 }
1566
1567                             case 58:
1568                                 switch (zzInput) {
1569                                     case 12:
1570                                         zzState = 88;
1571                                         break zzForNext;
1572                                     default:
1573                                         break zzForAction;
1574                                 }
1575
1576                             case 59:
1577                                 switch (zzInput) {
1578                                     case 16:
1579                                         zzState = 89;
1580                                         break zzForNext;
1581                                     default:
1582                                         break zzForAction;
1583                                 }
1584
1585                             case 60:
1586                                 switch (zzInput) {
1587                                     case 19:
1588                                         zzState = 90;
1589                                         break zzForNext;
1590                                     default:
1591                                         break zzForAction;
1592                                 }
1593
1594                             case 61:
1595                                 switch (zzInput) {
1596                                     case 13:
1597                                         zzState = 91;
1598                                         break zzForNext;
1599                                     default:
1600                                         break zzForAction;
1601                                 }
1602
1603                             case 62:
1604                                 switch (zzInput) {
1605                                     case 12:
1606                                         zzState = 92;
1607                                         break zzForNext;
1608                                     default:
1609                                         break zzForAction;
1610                                 }
1611
1612                             case 63:
1613                                 switch (zzInput) {
1614                                     case 23:
1615                                         zzState = 93;
1616                                         break zzForNext;
1617                                     default:
1618                                         break zzForAction;
1619                                 }
1620
1621                             case 64:
1622                                 switch (zzInput) {
1623                                     case 17:
1624                                         zzIsFinal = true;
1625                                         zzState = 94;
1626                                         break zzForNext;
1627                                     case 0:
1628                                     case 1:
1629                                     case 2:
1630                                     case 3:
1631                                     case 5:
1632                                     case 7:
1633                                     case 8:
1634                                     case 9:
1635                                     case 24:
1636                                         break zzForAction;
1637                                     default:
1638                                         zzIsFinal = true;
1639                                         zzNoLookAhead = true;
1640                                         zzState = 7;
1641                                         break zzForNext;
1642                                 }
1643
1644                             case 65:
1645                                 switch (zzInput) {
1646                                     case 11:
1647                                         zzIsFinal = true;
1648                                         zzState = 95;
1649                                         break zzForNext;
1650                                     default:
1651                                         break zzForAction;
1652                                 }
1653
1654                             case 66:
1655                                 switch (zzInput) {
1656                                     case 10:
1657                                         zzState = 96;
1658                                         break zzForNext;
1659                                     default:
1660                                         break zzForAction;
1661                                 }
1662
1663                             case 67:
1664                                 switch (zzInput) {
1665                                     case 17:
1666                                         zzState = 97;
1667                                         break zzForNext;
1668                                     default:
1669                                         break zzForAction;
1670                                 }
1671
1672                             case 68:
1673                                 switch (zzInput) {
1674                                     case 12:
1675                                         zzState = 88;
1676                                         break zzForNext;
1677                                     case 20:
1678                                         zzIsFinal = true;
1679                                         zzState = 95;
1680                                         break zzForNext;
1681                                     default:
1682                                         break zzForAction;
1683                                 }
1684
1685                             case 69:
1686                                 switch (zzInput) {
1687                                     case 10:
1688                                         zzState = 98;
1689                                         break zzForNext;
1690                                     default:
1691                                         break zzForAction;
1692                                 }
1693
1694                             case 70:
1695                                 switch (zzInput) {
1696                                     case 17:
1697                                         zzIsFinal = true;
1698                                         zzNoLookAhead = true;
1699                                         zzState = 20;
1700                                         break zzForNext;
1701                                     case 12:
1702                                         zzState = 92;
1703                                         break zzForNext;
1704                                     default:
1705                                         break zzForAction;
1706                                 }
1707
1708                             case 71:
1709                                 switch (zzInput) {
1710                                     case 0:
1711                                     case 1:
1712                                     case 2:
1713                                     case 3:
1714                                     case 5:
1715                                     case 7:
1716                                     case 8:
1717                                     case 9:
1718                                     case 24:
1719                                         break zzForAction;
1720                                     default:
1721                                         zzIsFinal = true;
1722                                         zzState = 99;
1723                                         break zzForNext;
1724                                 }
1725
1726                             case 72:
1727                                 switch (zzInput) {
1728                                     case 13:
1729                                         zzIsFinal = true;
1730                                         zzState = 71;
1731                                         break zzForNext;
1732                                     default:
1733                                         break zzForAction;
1734                                 }
1735
1736                             case 73:
1737                                 switch (zzInput) {
1738                                     case 23:
1739                                         zzState = 100;
1740                                         break zzForNext;
1741                                     default:
1742                                         break zzForAction;
1743                                 }
1744
1745                             case 74:
1746                                 switch (zzInput) {
1747                                     case 10:
1748                                         zzState = 101;
1749                                         break zzForNext;
1750                                     default:
1751                                         break zzForAction;
1752                                 }
1753
1754                             case 75:
1755                                 switch (zzInput) {
1756                                     case 18:
1757                                         zzState = 102;
1758                                         break zzForNext;
1759                                     default:
1760                                         break zzForAction;
1761                                 }
1762
1763                             case 76:
1764                                 switch (zzInput) {
1765                                     case 16:
1766                                         zzState = 103;
1767                                         break zzForNext;
1768                                     default:
1769                                         break zzForAction;
1770                                 }
1771
1772                             case 77:
1773                                 switch (zzInput) {
1774                                     case 21:
1775                                         zzIsFinal = true;
1776                                         zzState = 71;
1777                                         break zzForNext;
1778                                     default:
1779                                         break zzForAction;
1780                                 }
1781
1782                             case 78:
1783                                 switch (zzInput) {
1784                                     case 12:
1785                                         zzState = 104;
1786                                         break zzForNext;
1787                                     default:
1788                                         break zzForAction;
1789                                 }
1790
1791                             case 79:
1792                                 switch (zzInput) {
1793                                     case 23:
1794                                         zzState = 105;
1795                                         break zzForNext;
1796                                     default:
1797                                         break zzForAction;
1798                                 }
1799
1800                             case 80:
1801                                 switch (zzInput) {
1802                                     case 10:
1803                                         zzState = 106;
1804                                         break zzForNext;
1805                                     default:
1806                                         break zzForAction;
1807                                 }
1808
1809                             case 81:
1810                                 switch (zzInput) {
1811                                     case 17:
1812                                         zzIsFinal = true;
1813                                         zzNoLookAhead = true;
1814                                         zzState = 20;
1815                                         break zzForNext;
1816                                     case 12:
1817                                         zzState = 104;
1818                                         break zzForNext;
1819                                     default:
1820                                         break zzForAction;
1821                                 }
1822
1823                             case 82:
1824                                 switch (zzInput) {
1825                                     case 25:
1826                                         zzIsFinal = true;
1827                                         zzState = 107;
1828                                         break zzForNext;
1829                                     default:
1830                                         break zzForAction;
1831                                 }
1832
1833                             case 83:
1834                                 switch (zzInput) {
1835                                     case 19:
1836                                         zzIsFinal = true;
1837                                         zzState = 108;
1838                                         break zzForNext;
1839                                     case 0:
1840                                     case 1:
1841                                     case 2:
1842                                     case 3:
1843                                     case 5:
1844                                     case 7:
1845                                     case 8:
1846                                     case 9:
1847                                     case 24:
1848                                         break zzForAction;
1849                                     default:
1850                                         zzIsFinal = true;
1851                                         zzState = 10;
1852                                         break zzForNext;
1853                                 }
1854
1855                             case 84:
1856                                 switch (zzInput) {
1857                                     case 16:
1858                                         zzIsFinal = true;
1859                                         zzState = 109;
1860                                         break zzForNext;
1861                                     case 0:
1862                                     case 1:
1863                                     case 2:
1864                                     case 3:
1865                                     case 5:
1866                                     case 7:
1867                                     case 8:
1868                                     case 9:
1869                                     case 24:
1870                                         break zzForAction;
1871                                     default:
1872                                         zzIsFinal = true;
1873                                         zzState = 10;
1874                                         break zzForNext;
1875                                 }
1876
1877                             case 85:
1878                                 switch (zzInput) {
1879                                     case 11:
1880                                         zzIsFinal = true;
1881                                         zzState = 110;
1882                                         break zzForNext;
1883                                     case 0:
1884                                     case 1:
1885                                     case 2:
1886                                     case 3:
1887                                     case 5:
1888                                     case 7:
1889                                     case 8:
1890                                     case 9:
1891                                     case 24:
1892                                         break zzForAction;
1893                                     default:
1894                                         zzIsFinal = true;
1895                                         zzState = 10;
1896                                         break zzForNext;
1897                                 }
1898
1899                             case 86:
1900                                 switch (zzInput) {
1901                                     case 17:
1902                                         zzIsFinal = true;
1903                                         zzState = 111;
1904                                         break zzForNext;
1905                                     case 0:
1906                                     case 1:
1907                                     case 2:
1908                                     case 3:
1909                                     case 5:
1910                                     case 7:
1911                                     case 8:
1912                                     case 9:
1913                                     case 24:
1914                                         break zzForAction;
1915                                     default:
1916                                         zzIsFinal = true;
1917                                         zzState = 10;
1918                                         break zzForNext;
1919                                 }
1920
1921                             case 87:
1922                                 switch (zzInput) {
1923                                     case 2:
1924                                         zzIsFinal = true;
1925                                         break zzForNext;
1926                                     case 1:
1927                                     case 3:
1928                                         break zzForAction;
1929                                     default:
1930                                         zzState = 55;
1931                                         break zzForNext;
1932                                 }
1933
1934                             case 88:
1935                                 switch (zzInput) {
1936                                     case 11:
1937                                         zzIsFinal = true;
1938                                         zzNoLookAhead = true;
1939                                         zzState = 7;
1940                                         break zzForNext;
1941                                     default:
1942                                         break zzForAction;
1943                                 }
1944
1945                             case 89:
1946                                 switch (zzInput) {
1947                                     case 10:
1948                                         zzState = 112;
1949                                         break zzForNext;
1950                                     default:
1951                                         break zzForAction;
1952                                 }
1953
1954                             case 90:
1955                                 switch (zzInput) {
1956                                     case 17:
1957                                         zzState = 113;
1958                                         break zzForNext;
1959                                     default:
1960                                         break zzForAction;
1961                                 }
1962
1963                             case 91:
1964                                 switch (zzInput) {
1965                                     case 20:
1966                                         zzIsFinal = true;
1967                                         zzNoLookAhead = true;
1968                                         zzState = 7;
1969                                         break zzForNext;
1970                                     default:
1971                                         break zzForAction;
1972                                 }
1973
1974                             case 92:
1975                                 switch (zzInput) {
1976                                     case 10:
1977                                         zzState = 114;
1978                                         break zzForNext;
1979                                     default:
1980                                         break zzForAction;
1981                                 }
1982
1983                             case 93:
1984                                 switch (zzInput) {
1985                                     case 17:
1986                                         zzIsFinal = true;
1987                                         zzNoLookAhead = true;
1988                                         zzState = 7;
1989                                         break zzForNext;
1990                                     default:
1991                                         break zzForAction;
1992                                 }
1993
1994                             case 94:
1995                                 switch (zzInput) {
1996                                     case 18:
1997                                         zzState = 115;
1998                                         break zzForNext;
1999                                     default:
2000                                         break zzForAction;
2001                                 }
2002
2003                             case 95:
2004                                 switch (zzInput) {
2005                                     case 0:
2006                                     case 1:
2007                                     case 2:
2008                                     case 3:
2009                                     case 5:
2010                                     case 7:
2011                                     case 8:
2012                                     case 9:
2013                                     case 24:
2014                                         break zzForAction;
2015                                     default:
2016                                         zzIsFinal = true;
2017                                         zzNoLookAhead = true;
2018                                         zzState = 7;
2019                                         break zzForNext;
2020                                 }
2021
2022                             case 96:
2023                                 switch (zzInput) {
2024                                     case 15:
2025                                         zzState = 116;
2026                                         break zzForNext;
2027                                     default:
2028                                         break zzForAction;
2029                                 }
2030
2031                             case 97:
2032                                 switch (zzInput) {
2033                                     case 16:
2034                                         zzState = 117;
2035                                         break zzForNext;
2036                                     default:
2037                                         break zzForAction;
2038                                 }
2039
2040                             case 98:
2041                                 switch (zzInput) {
2042                                     case 20:
2043                                         zzState = 118;
2044                                         break zzForNext;
2045                                     default:
2046                                         break zzForAction;
2047                                 }
2048
2049                             case 99:
2050                                 switch (zzInput) {
2051                                     case 0:
2052                                     case 1:
2053                                     case 2:
2054                                     case 3:
2055                                     case 5:
2056                                     case 7:
2057                                     case 8:
2058                                     case 9:
2059                                     case 24:
2060                                         break zzForAction;
2061                                     default:
2062                                         zzIsFinal = true;
2063                                         break zzForNext;
2064                                 }
2065
2066                             case 100:
2067                                 switch (zzInput) {
2068                                     case 19:
2069                                         zzState = 119;
2070                                         break zzForNext;
2071                                     default:
2072                                         break zzForAction;
2073                                 }
2074
2075                             case 101:
2076                                 switch (zzInput) {
2077                                     case 16:
2078                                         zzState = 120;
2079                                         break zzForNext;
2080                                     default:
2081                                         break zzForAction;
2082                                 }
2083
2084                             case 102:
2085                                 switch (zzInput) {
2086                                     case 17:
2087                                         zzIsFinal = true;
2088                                         zzState = 121;
2089                                         break zzForNext;
2090                                     default:
2091                                         break zzForAction;
2092                                 }
2093
2094                             case 103:
2095                                 switch (zzInput) {
2096                                     case 17:
2097                                         zzState = 122;
2098                                         break zzForNext;
2099                                     default:
2100                                         break zzForAction;
2101                                 }
2102
2103                             case 104:
2104                                 switch (zzInput) {
2105                                     case 10:
2106                                         zzState = 123;
2107                                         break zzForNext;
2108                                     default:
2109                                         break zzForAction;
2110                                 }
2111
2112                             case 105:
2113                                 switch (zzInput) {
2114                                     case 17:
2115                                         zzIsFinal = true;
2116                                         zzNoLookAhead = true;
2117                                         zzState = 30;
2118                                         break zzForNext;
2119                                     default:
2120                                         break zzForAction;
2121                                 }
2122
2123                             case 106:
2124                                 switch (zzInput) {
2125                                     case 20:
2126                                         zzState = 124;
2127                                         break zzForNext;
2128                                     default:
2129                                         break zzForAction;
2130                                 }
2131
2132                             case 107:
2133                                 switch (zzInput) {
2134                                     case 11:
2135                                         zzState = 125;
2136                                         break zzForNext;
2137                                     default:
2138                                         break zzForAction;
2139                                 }
2140
2141                             case 108:
2142                                 switch (zzInput) {
2143                                     case 20:
2144                                         zzIsFinal = true;
2145                                         zzState = 126;
2146                                         break zzForNext;
2147                                     case 0:
2148                                     case 1:
2149                                     case 2:
2150                                     case 3:
2151                                     case 5:
2152                                     case 7:
2153                                     case 8:
2154                                     case 9:
2155                                     case 24:
2156                                         break zzForAction;
2157                                     default:
2158                                         zzIsFinal = true;
2159                                         zzState = 10;
2160                                         break zzForNext;
2161                                 }
2162
2163                             case 109:
2164                                 switch (zzInput) {
2165                                     case 17:
2166                                         zzIsFinal = true;
2167                                         zzState = 48;
2168                                         break zzForNext;
2169                                     case 0:
2170                                     case 1:
2171                                     case 2:
2172                                     case 3:
2173                                     case 5:
2174                                     case 7:
2175                                     case 8:
2176                                     case 9:
2177                                     case 24:
2178                                         break zzForAction;
2179                                     default:
2180                                         zzIsFinal = true;
2181                                         zzState = 10;
2182                                         break zzForNext;
2183                                 }
2184
2185                             case 110:
2186                                 switch (zzInput) {
2187                                     case 22:
2188                                         zzIsFinal = true;
2189                                         zzState = 127;
2190                                         break zzForNext;
2191                                     case 0:
2192                                     case 1:
2193                                     case 2:
2194                                     case 3:
2195                                     case 5:
2196                                     case 7:
2197                                     case 8:
2198                                     case 9:
2199                                     case 24:
2200                                         break zzForAction;
2201                                     default:
2202                                         zzIsFinal = true;
2203                                         zzState = 10;
2204                                         break zzForNext;
2205                                 }
2206
2207                             case 111:
2208                                 switch (zzInput) {
2209                                     case 19:
2210                                         zzIsFinal = true;
2211                                         zzState = 128;
2212                                         break zzForNext;
2213                                     case 0:
2214                                     case 1:
2215                                     case 2:
2216                                     case 3:
2217                                     case 5:
2218                                     case 7:
2219                                     case 8:
2220                                     case 9:
2221                                     case 24:
2222                                         break zzForAction;
2223                                     default:
2224                                         zzIsFinal = true;
2225                                         zzState = 10;
2226                                         break zzForNext;
2227                                 }
2228
2229                             case 112:
2230                                 switch (zzInput) {
2231                                     case 15:
2232                                         zzState = 129;
2233                                         break zzForNext;
2234                                     default:
2235                                         break zzForAction;
2236                                 }
2237
2238                             case 113:
2239                                 switch (zzInput) {
2240                                     case 16:
2241                                         zzState = 130;
2242                                         break zzForNext;
2243                                     default:
2244                                         break zzForAction;
2245                                 }
2246
2247                             case 114:
2248                                 switch (zzInput) {
2249                                     case 20:
2250                                         zzState = 131;
2251                                         break zzForNext;
2252                                     default:
2253                                         break zzForAction;
2254                                 }
2255
2256                             case 115:
2257                                 switch (zzInput) {
2258                                     case 16:
2259                                         zzState = 93;
2260                                         break zzForNext;
2261                                     default:
2262                                         break zzForAction;
2263                                 }
2264
2265                             case 116:
2266                                 switch (zzInput) {
2267                                     case 14:
2268                                         zzIsFinal = true;
2269                                         zzState = 95;
2270                                         break zzForNext;
2271                                     default:
2272                                         break zzForAction;
2273                                 }
2274
2275                             case 117:
2276                                 switch (zzInput) {
2277                                     case 17:
2278                                         zzState = 132;
2279                                         break zzForNext;
2280                                     default:
2281                                         break zzForAction;
2282                                 }
2283
2284                             case 118:
2285                                 switch (zzInput) {
2286                                     case 19:
2287                                         zzState = 133;
2288                                         break zzForNext;
2289                                     default:
2290                                         break zzForAction;
2291                                 }
2292
2293                             case 119:
2294                                 switch (zzInput) {
2295                                     case 20:
2296                                         zzState = 134;
2297                                         break zzForNext;
2298                                     default:
2299                                         break zzForAction;
2300                                 }
2301
2302                             case 120:
2303                                 switch (zzInput) {
2304                                     case 17:
2305                                         zzIsFinal = true;
2306                                         zzState = 71;
2307                                         break zzForNext;
2308                                     default:
2309                                         break zzForAction;
2310                                 }
2311
2312                             case 121:
2313                                 switch (zzInput) {
2314                                     case 10:
2315                                         zzState = 135;
2316                                         break zzForNext;
2317                                     default:
2318                                         break zzForAction;
2319                                 }
2320
2321                             case 122:
2322                                 switch (zzInput) {
2323                                     case 19:
2324                                         zzState = 136;
2325                                         break zzForNext;
2326                                     default:
2327                                         break zzForAction;
2328                                 }
2329
2330                             case 123:
2331                                 switch (zzInput) {
2332                                     case 20:
2333                                         zzState = 137;
2334                                         break zzForNext;
2335                                     default:
2336                                         break zzForAction;
2337                                 }
2338
2339                             case 124:
2340                                 switch (zzInput) {
2341                                     case 19:
2342                                         zzState = 138;
2343                                         break zzForNext;
2344                                     default:
2345                                         break zzForAction;
2346                                 }
2347
2348                             case 125:
2349                                 switch (zzInput) {
2350                                     case 22:
2351                                         zzState = 139;
2352                                         break zzForNext;
2353                                     default:
2354                                         break zzForAction;
2355                                 }
2356
2357                             case 126:
2358                                 switch (zzInput) {
2359                                     case 10:
2360                                         zzIsFinal = true;
2361                                         zzState = 140;
2362                                         break zzForNext;
2363                                     case 0:
2364                                     case 1:
2365                                     case 2:
2366                                     case 3:
2367                                     case 5:
2368                                     case 7:
2369                                     case 8:
2370                                     case 9:
2371                                     case 24:
2372                                         break zzForAction;
2373                                     default:
2374                                         zzIsFinal = true;
2375                                         zzState = 10;
2376                                         break zzForNext;
2377                                 }
2378
2379                             case 127:
2380                                 switch (zzInput) {
2381                                     case 23:
2382                                         zzIsFinal = true;
2383                                         zzState = 141;
2384                                         break zzForNext;
2385                                     case 0:
2386                                     case 1:
2387                                     case 2:
2388                                     case 3:
2389                                     case 5:
2390                                     case 7:
2391                                     case 8:
2392                                     case 9:
2393                                     case 24:
2394                                         break zzForAction;
2395                                     default:
2396                                         zzIsFinal = true;
2397                                         zzState = 10;
2398                                         break zzForNext;
2399                                 }
2400
2401                             case 128:
2402                                 switch (zzInput) {
2403                                     case 20:
2404                                         zzIsFinal = true;
2405                                         zzState = 48;
2406                                         break zzForNext;
2407                                     case 0:
2408                                     case 1:
2409                                     case 2:
2410                                     case 3:
2411                                     case 5:
2412                                     case 7:
2413                                     case 8:
2414                                     case 9:
2415                                     case 24:
2416                                         break zzForAction;
2417                                     default:
2418                                         zzIsFinal = true;
2419                                         zzState = 10;
2420                                         break zzForNext;
2421                                 }
2422
2423                             case 129:
2424                                 switch (zzInput) {
2425                                     case 14:
2426                                         zzIsFinal = true;
2427                                         zzNoLookAhead = true;
2428                                         zzState = 7;
2429                                         break zzForNext;
2430                                     default:
2431                                         break zzForAction;
2432                                 }
2433
2434                             case 130:
2435                                 switch (zzInput) {
2436                                     case 17:
2437                                         zzState = 142;
2438                                         break zzForNext;
2439                                     default:
2440                                         break zzForAction;
2441                                 }
2442
2443                             case 131:
2444                                 switch (zzInput) {
2445                                     case 19:
2446                                         zzState = 143;
2447                                         break zzForNext;
2448                                     default:
2449                                         break zzForAction;
2450                                 }
2451
2452                             case 132:
2453                                 switch (zzInput) {
2454                                     case 18:
2455                                         zzIsFinal = true;
2456                                         zzState = 95;
2457                                         break zzForNext;
2458                                     default:
2459                                         break zzForAction;
2460                                 }
2461
2462                             case 133:
2463                                 switch (zzInput) {
2464                                     case 23:
2465                                         zzState = 144;
2466                                         break zzForNext;
2467                                     default:
2468                                         break zzForAction;
2469                                 }
2470
2471                             case 134:
2472                                 switch (zzInput) {
2473                                     case 10:
2474                                         zzState = 145;
2475                                         break zzForNext;
2476                                     default:
2477                                         break zzForAction;
2478                                 }
2479
2480                             case 135:
2481                                 switch (zzInput) {
2482                                     case 11:
2483                                         zzIsFinal = true;
2484                                         zzNoLookAhead = true;
2485                                         zzState = 20;
2486                                         break zzForNext;
2487                                     default:
2488                                         break zzForAction;
2489                                 }
2490
2491                             case 136:
2492                                 switch (zzInput) {
2493                                     case 20:
2494                                         zzIsFinal = true;
2495                                         zzState = 71;
2496                                         break zzForNext;
2497                                     default:
2498                                         break zzForAction;
2499                                 }
2500
2501                             case 137:
2502                                 switch (zzInput) {
2503                                     case 19:
2504                                         zzState = 146;
2505                                         break zzForNext;
2506                                     default:
2507                                         break zzForAction;
2508                                 }
2509
2510                             case 138:
2511                                 switch (zzInput) {
2512                                     case 23:
2513                                         zzState = 147;
2514                                         break zzForNext;
2515                                     default:
2516                                         break zzForAction;
2517                                 }
2518
2519                             case 139:
2520                                 switch (zzInput) {
2521                                     case 23:
2522                                         zzState = 148;
2523                                         break zzForNext;
2524                                     default:
2525                                         break zzForAction;
2526                                 }
2527
2528                             case 140:
2529                                 switch (zzInput) {
2530                                     case 12:
2531                                         zzIsFinal = true;
2532                                         zzState = 149;
2533                                         break zzForNext;
2534                                     case 0:
2535                                     case 1:
2536                                     case 2:
2537                                     case 3:
2538                                     case 5:
2539                                     case 7:
2540                                     case 8:
2541                                     case 9:
2542                                     case 24:
2543                                         break zzForAction;
2544                                     default:
2545                                         zzIsFinal = true;
2546                                         zzState = 10;
2547                                         break zzForNext;
2548                                 }
2549
2550                             case 141:
2551                                 switch (zzInput) {
2552                                     case 19:
2553                                         zzIsFinal = true;
2554                                         zzState = 150;
2555                                         break zzForNext;
2556                                     case 0:
2557                                     case 1:
2558                                     case 2:
2559                                     case 3:
2560                                     case 5:
2561                                     case 7:
2562                                     case 8:
2563                                     case 9:
2564                                     case 24:
2565                                         break zzForAction;
2566                                     default:
2567                                         zzIsFinal = true;
2568                                         zzState = 10;
2569                                         break zzForNext;
2570                                 }
2571
2572                             case 142:
2573                                 switch (zzInput) {
2574                                     case 18:
2575                                         zzIsFinal = true;
2576                                         zzNoLookAhead = true;
2577                                         zzState = 7;
2578                                         break zzForNext;
2579                                     default:
2580                                         break zzForAction;
2581                                 }
2582
2583                             case 143:
2584                                 switch (zzInput) {
2585                                     case 23:
2586                                         zzState = 151;
2587                                         break zzForNext;
2588                                     default:
2589                                         break zzForAction;
2590                                 }
2591
2592                             case 144:
2593                                 switch (zzInput) {
2594                                     case 22:
2595                                         zzState = 152;
2596                                         break zzForNext;
2597                                     default:
2598                                         break zzForAction;
2599                                 }
2600
2601                             case 145:
2602                                 switch (zzInput) {
2603                                     case 12:
2604                                         zzState = 153;
2605                                         break zzForNext;
2606                                     default:
2607                                         break zzForAction;
2608                                 }
2609
2610                             case 146:
2611                                 switch (zzInput) {
2612                                     case 23:
2613                                         zzState = 154;
2614                                         break zzForNext;
2615                                     default:
2616                                         break zzForAction;
2617                                 }
2618
2619                             case 147:
2620                                 switch (zzInput) {
2621                                     case 22:
2622                                         zzState = 155;
2623                                         break zzForNext;
2624                                     default:
2625                                         break zzForAction;
2626                                 }
2627
2628                             case 148:
2629                                 switch (zzInput) {
2630                                     case 19:
2631                                         zzState = 156;
2632                                         break zzForNext;
2633                                     default:
2634                                         break zzForAction;
2635                                 }
2636
2637                             case 149:
2638                                 switch (zzInput) {
2639                                     case 23:
2640                                         zzIsFinal = true;
2641                                         zzState = 48;
2642                                         break zzForNext;
2643                                     case 0:
2644                                     case 1:
2645                                     case 2:
2646                                     case 3:
2647                                     case 5:
2648                                     case 7:
2649                                     case 8:
2650                                     case 9:
2651                                     case 24:
2652                                         break zzForAction;
2653                                     default:
2654                                         zzIsFinal = true;
2655                                         zzState = 10;
2656                                         break zzForNext;
2657                                 }
2658
2659                             case 150:
2660                                 switch (zzInput) {
2661                                     case 20:
2662                                         zzIsFinal = true;
2663                                         zzState = 157;
2664                                         break zzForNext;
2665                                     case 0:
2666                                     case 1:
2667                                     case 2:
2668                                     case 3:
2669                                     case 5:
2670                                     case 7:
2671                                     case 8:
2672                                     case 9:
2673                                     case 24:
2674                                         break zzForAction;
2675                                     default:
2676                                         zzIsFinal = true;
2677                                         zzState = 10;
2678                                         break zzForNext;
2679                                 }
2680
2681                             case 151:
2682                                 switch (zzInput) {
2683                                     case 22:
2684                                         zzState = 158;
2685                                         break zzForNext;
2686                                     default:
2687                                         break zzForAction;
2688                                 }
2689
2690                             case 152:
2691                                 switch (zzInput) {
2692                                     case 11:
2693                                         zzIsFinal = true;
2694                                         zzState = 159;
2695                                         break zzForNext;
2696                                     default:
2697                                         break zzForAction;
2698                                 }
2699
2700                             case 153:
2701                                 switch (zzInput) {
2702                                     case 23:
2703                                         zzIsFinal = true;
2704                                         zzState = 71;
2705                                         break zzForNext;
2706                                     default:
2707                                         break zzForAction;
2708                                 }
2709
2710                             case 154:
2711                                 switch (zzInput) {
2712                                     case 22:
2713                                         zzState = 160;
2714                                         break zzForNext;
2715                                     default:
2716                                         break zzForAction;
2717                                 }
2718
2719                             case 155:
2720                                 switch (zzInput) {
2721                                     case 11:
2722                                         zzState = 161;
2723                                         break zzForNext;
2724                                     default:
2725                                         break zzForAction;
2726                                 }
2727
2728                             case 156:
2729                                 switch (zzInput) {
2730                                     case 20:
2731                                         zzState = 162;
2732                                         break zzForNext;
2733                                     default:
2734                                         break zzForAction;
2735                                 }
2736
2737                             case 157:
2738                                 switch (zzInput) {
2739                                     case 10:
2740                                         zzIsFinal = true;
2741                                         zzState = 163;
2742                                         break zzForNext;
2743                                     case 0:
2744                                     case 1:
2745                                     case 2:
2746                                     case 3:
2747                                     case 5:
2748                                     case 7:
2749                                     case 8:
2750                                     case 9:
2751                                     case 24:
2752                                         break zzForAction;
2753                                     default:
2754                                         zzIsFinal = true;
2755                                         zzState = 10;
2756                                         break zzForNext;
2757                                 }
2758
2759                             case 158:
2760                                 switch (zzInput) {
2761                                     case 11:
2762                                         zzIsFinal = true;
2763                                         zzState = 164;
2764                                         break zzForNext;
2765                                     default:
2766                                         break zzForAction;
2767                                 }
2768
2769                             case 159:
2770                                 switch (zzInput) {
2771                                     case 25:
2772                                         zzIsFinal = true;
2773                                         zzState = 165;
2774                                         break zzForNext;
2775                                     case 0:
2776                                     case 1:
2777                                     case 2:
2778                                     case 3:
2779                                     case 5:
2780                                     case 7:
2781                                     case 8:
2782                                     case 9:
2783                                     case 24:
2784                                         break zzForAction;
2785                                     default:
2786                                         zzIsFinal = true;
2787                                         zzNoLookAhead = true;
2788                                         zzState = 7;
2789                                         break zzForNext;
2790                                 }
2791
2792                             case 160:
2793                                 switch (zzInput) {
2794                                     case 11:
2795                                         zzState = 166;
2796                                         break zzForNext;
2797                                     default:
2798                                         break zzForAction;
2799                                 }
2800
2801                             case 161:
2802                                 switch (zzInput) {
2803                                     case 25:
2804                                         zzState = 167;
2805                                         break zzForNext;
2806                                     default:
2807                                         break zzForAction;
2808                                 }
2809
2810                             case 162:
2811                                 switch (zzInput) {
2812                                     case 10:
2813                                         zzState = 168;
2814                                         break zzForNext;
2815                                     default:
2816                                         break zzForAction;
2817                                 }
2818
2819                             case 163:
2820                                 switch (zzInput) {
2821                                     case 12:
2822                                         zzIsFinal = true;
2823                                         zzState = 169;
2824                                         break zzForNext;
2825                                     case 0:
2826                                     case 1:
2827                                     case 2:
2828                                     case 3:
2829                                     case 5:
2830                                     case 7:
2831                                     case 8:
2832                                     case 9:
2833                                     case 24:
2834                                         break zzForAction;
2835                                     default:
2836                                         zzIsFinal = true;
2837                                         zzState = 10;
2838                                         break zzForNext;
2839                                 }
2840
2841                             case 164:
2842                                 switch (zzInput) {
2843                                     case 25:
2844                                         zzState = 63;
2845                                         break zzForNext;
2846                                     default:
2847                                         break zzForAction;
2848                                 }
2849
2850                             case 165:
2851                                 switch (zzInput) {
2852                                     case 23:
2853                                         zzState = 170;
2854                                         break zzForNext;
2855                                     default:
2856                                         break zzForAction;
2857                                 }
2858
2859                             case 166:
2860                                 switch (zzInput) {
2861                                     case 25:
2862                                         zzState = 79;
2863                                         break zzForNext;
2864                                     default:
2865                                         break zzForAction;
2866                                 }
2867
2868                             case 167:
2869                                 switch (zzInput) {
2870                                     case 23:
2871                                         zzState = 170;
2872                                         break zzForNext;
2873                                     default:
2874                                         break zzForAction;
2875                                 }
2876
2877                             case 168:
2878                                 switch (zzInput) {
2879                                     case 12:
2880                                         zzState = 171;
2881                                         break zzForNext;
2882                                     default:
2883                                         break zzForAction;
2884                                 }
2885
2886                             case 169:
2887                                 switch (zzInput) {
2888                                     case 23:
2889                                         zzIsFinal = true;
2890                                         zzState = 172;
2891                                         break zzForNext;
2892                                     case 0:
2893                                     case 1:
2894                                     case 2:
2895                                     case 3:
2896                                     case 5:
2897                                     case 7:
2898                                     case 8:
2899                                     case 9:
2900                                     case 24:
2901                                         break zzForAction;
2902                                     default:
2903                                         zzIsFinal = true;
2904                                         zzState = 10;
2905                                         break zzForNext;
2906                                 }
2907
2908                             case 170:
2909                                 switch (zzInput) {
2910                                     case 17:
2911                                         zzIsFinal = true;
2912                                         zzNoLookAhead = true;
2913                                         zzState = 20;
2914                                         break zzForNext;
2915                                     default:
2916                                         break zzForAction;
2917                                 }
2918
2919                             case 171:
2920                                 switch (zzInput) {
2921                                     case 23:
2922                                         zzIsFinal = true;
2923                                         zzNoLookAhead = true;
2924                                         zzState = 7;
2925                                         break zzForNext;
2926                                     default:
2927                                         break zzForAction;
2928                                 }
2929
2930                             case 172:
2931                                 switch (zzInput) {
2932                                     case 0:
2933                                     case 1:
2934                                     case 2:
2935                                     case 3:
2936                                     case 5:
2937                                     case 7:
2938                                     case 8:
2939                                     case 9:
2940                                     case 24:
2941                                         break zzForAction;
2942                                     default:
2943                                         zzIsFinal = true;
2944                                         zzState = 10;
2945                                         break zzForNext;
2946                                 }
2947
2948                             default:
2949                                 // if this is ever reached, there is a serious bug in JFlex
2950                                 zzScanError(ZZ_UNKNOWN_ERROR);
2951                                 break;
2952                         }
2953                     }
2954
2955                     if ( zzIsFinal ) {
2956                         zzAction = zzState;
2957                         zzMarkedPosL = zzCurrentPosL;
2958                         if ( zzNoLookAhead ) {
2959                             break zzForAction;
2960                         }
2961                     }
2962
2963                 }
2964             }
2965
2966             // store back cached position
2967             zzMarkedPos = zzMarkedPosL;
2968
2969             switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
2970                 case 7 :
2971                 {
2972                     char c = yycharat(yylength() - 2);
2973                     if (c == ')' || c == ']' || c == '}') {
2974                         transp = true;
2975                         return 0;
2976                     }
2977                 }
2978                 case 8:
2979                     break;
2980                 case 5: {
2981                     if (scilabLexer.getKeyword(start - yychar, false) == ScilabLexerConstants.STRING) {
2982                         savePos = start - yychar - scilabLexer.beginString - scilabLexer.start;
2983                         yybegin(SPEC);
2984                     } else {
2985                         yybegin(RL);
2986                     }
2987                 }
2988                 case 9:
2989                     break;
2990                 case 4: {
2991                     yypushback(1);
2992                     yybegin(PSNART);
2993                 }
2994                 case 10:
2995                     break;
2996                 case 2: {
2997                     return 0;
2998                 }
2999                 case 11:
3000                     break;
3001                 case 6: {
3002                     if (--savePos == 0) {
3003                         yybegin(RL);
3004                     }
3005                 }
3006                 case 12:
3007                     break;
3008                 case 3: {
3009                     return 1;
3010                 }
3011                 case 13:
3012                     break;
3013                 case 1: {
3014                 }
3015                 case 14:
3016                     break;
3017                 default:
3018                     if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
3019                         zzAtEOF = true;
3020                         {
3021                             return -1;
3022                         }
3023                     } else {
3024                         zzScanError(ZZ_NO_MATCH);
3025                     }
3026             }
3027         }
3028     }
3029
3030
3031 }