View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. JspParserTokenManager.java */
2   /*** 
3    * JSP Parser for PMD.
4    * @author Pieter � Application Engineers NV/SA � http://www.ae.be
5    */
6   
7   package net.sourceforge.pmd.jsp.ast;
8   
9   public class JspParserTokenManager implements JspParserConstants
10  {
11    public  java.io.PrintStream debugStream = System.out;
12    public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
13  private final int jjStopStringLiteralDfa_9(int pos, long active0)
14  {
15     switch (pos)
16     {
17        case 0:
18           if ((active0 & 0x40000000000L) != 0L)
19              return 2;
20           return -1;
21        default :
22           return -1;
23     }
24  }
25  private final int jjStartNfa_9(int pos, long active0)
26  {
27     return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
28  }
29  private final int jjStopAtPos(int pos, int kind)
30  {
31     jjmatchedKind = kind;
32     jjmatchedPos = pos;
33     return pos + 1;
34  }
35  private final int jjStartNfaWithStates_9(int pos, int kind, int state)
36  {
37     jjmatchedKind = kind;
38     jjmatchedPos = pos;
39     try { curChar = input_stream.readChar(); }
40     catch(java.io.IOException e) { return pos + 1; }
41     return jjMoveNfa_9(state, pos + 1);
42  }
43  private final int jjMoveStringLiteralDfa0_9()
44  {
45     switch(curChar)
46     {
47        case 37:
48           return jjMoveStringLiteralDfa1_9(0x40000000000L);
49        default :
50           return jjMoveNfa_9(3, 0);
51     }
52  }
53  private final int jjMoveStringLiteralDfa1_9(long active0)
54  {
55     try { curChar = input_stream.readChar(); }
56     catch(java.io.IOException e) {
57        jjStopStringLiteralDfa_9(0, active0);
58        return 1;
59     }
60     switch(curChar)
61     {
62        case 62:
63           if ((active0 & 0x40000000000L) != 0L)
64              return jjStopAtPos(1, 42);
65           break;
66        default :
67           break;
68     }
69     return jjStartNfa_9(0, active0);
70  }
71  private final void jjCheckNAdd(int state)
72  {
73     if (jjrounds[state] != jjround)
74     {
75        jjstateSet[jjnewStateCnt++] = state;
76        jjrounds[state] = jjround;
77     }
78  }
79  private final void jjAddStates(int start, int end)
80  {
81     do {
82        jjstateSet[jjnewStateCnt++] = jjnextStates[start];
83     } while (start++ != end);
84  }
85  private final void jjCheckNAddTwoStates(int state1, int state2)
86  {
87     jjCheckNAdd(state1);
88     jjCheckNAdd(state2);
89  }
90  private final void jjCheckNAddStates(int start, int end)
91  {
92     do {
93        jjCheckNAdd(jjnextStates[start]);
94     } while (start++ != end);
95  }
96  private final void jjCheckNAddStates(int start)
97  {
98     jjCheckNAdd(jjnextStates[start]);
99     jjCheckNAdd(jjnextStates[start + 1]);
100 }
101 static final long[] jjbitVec0 = {
102    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
103 };
104 private final int jjMoveNfa_9(int startState, int curPos)
105 {
106    int[] nextStates;
107    int startsAt = 0;
108    jjnewStateCnt = 3;
109    int i = 1;
110    jjstateSet[0] = startState;
111    int j, kind = 0x7fffffff;
112    for (;;)
113    {
114       if (++jjround == 0x7fffffff)
115          ReInitRounds();
116       if (curChar < 64)
117       {
118          long l = 1L << curChar;
119          MatchLoop: do
120          {
121             switch(jjstateSet[--i])
122             {
123                case 3:
124                   if ((0xffffffdfffffffffL & l) != 0L)
125                   {
126                      if (kind > 43)
127                         kind = 43;
128                      jjCheckNAddTwoStates(0, 1);
129                   }
130                   else if (curChar == 37)
131                      jjstateSet[jjnewStateCnt++] = 2;
132                   break;
133                case 0:
134                   if ((0xffffffdfffffffffL & l) == 0L)
135                      break;
136                   if (kind > 43)
137                      kind = 43;
138                   jjCheckNAddTwoStates(0, 1);
139                   break;
140                case 1:
141                   if (curChar == 37)
142                      jjstateSet[jjnewStateCnt++] = 2;
143                   break;
144                case 2:
145                   if ((0xbfffffffffffffffL & l) == 0L)
146                      break;
147                   if (kind > 43)
148                      kind = 43;
149                   jjCheckNAddTwoStates(0, 1);
150                   break;
151                default : break;
152             }
153          } while(i != startsAt);
154       }
155       else if (curChar < 128)
156       {
157          long l = 1L << (curChar & 077);
158          MatchLoop: do
159          {
160             switch(jjstateSet[--i])
161             {
162                case 3:
163                case 0:
164                case 2:
165                   if (kind > 43)
166                      kind = 43;
167                   jjCheckNAddTwoStates(0, 1);
168                   break;
169                default : break;
170             }
171          } while(i != startsAt);
172       }
173       else
174       {
175          int i2 = (curChar & 0xff) >> 6;
176          long l2 = 1L << (curChar & 077);
177          MatchLoop: do
178          {
179             switch(jjstateSet[--i])
180             {
181                case 3:
182                case 0:
183                case 2:
184                   if ((jjbitVec0[i2] & l2) == 0L)
185                      break;
186                   if (kind > 43)
187                      kind = 43;
188                   jjCheckNAddTwoStates(0, 1);
189                   break;
190                default : break;
191             }
192          } while(i != startsAt);
193       }
194       if (kind != 0x7fffffff)
195       {
196          jjmatchedKind = kind;
197          jjmatchedPos = curPos;
198          kind = 0x7fffffff;
199       }
200       ++curPos;
201       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
202          return curPos;
203       try { curChar = input_stream.readChar(); }
204       catch(java.io.IOException e) { return curPos; }
205    }
206 }
207 private final int jjMoveStringLiteralDfa0_4()
208 {
209    switch(curChar)
210    {
211       case 93:
212          return jjMoveStringLiteralDfa1_4(0x80000000000000L);
213       default :
214          return 1;
215    }
216 }
217 private final int jjMoveStringLiteralDfa1_4(long active0)
218 {
219    try { curChar = input_stream.readChar(); }
220    catch(java.io.IOException e) {
221       return 1;
222    }
223    switch(curChar)
224    {
225       case 93:
226          return jjMoveStringLiteralDfa2_4(active0, 0x80000000000000L);
227       default :
228          return 2;
229    }
230 }
231 private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
232 {
233    if (((active0 &= old0)) == 0L)
234       return 2;
235    try { curChar = input_stream.readChar(); }
236    catch(java.io.IOException e) {
237       return 2;
238    }
239    switch(curChar)
240    {
241       case 62:
242          if ((active0 & 0x80000000000000L) != 0L)
243             return jjStopAtPos(2, 55);
244          break;
245       default :
246          return 3;
247    }
248    return 3;
249 }
250 private final int jjMoveStringLiteralDfa0_6()
251 {
252    return jjMoveNfa_6(1, 0);
253 }
254 static final long[] jjbitVec1 = {
255    0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
256 };
257 private final int jjMoveNfa_6(int startState, int curPos)
258 {
259    int[] nextStates;
260    int startsAt = 0;
261    jjnewStateCnt = 3;
262    int i = 1;
263    jjstateSet[0] = startState;
264    int j, kind = 0x7fffffff;
265    for (;;)
266    {
267       if (++jjround == 0x7fffffff)
268          ReInitRounds();
269       if (curChar < 64)
270       {
271          long l = 1L << curChar;
272          MatchLoop: do
273          {
274             switch(jjstateSet[--i])
275             {
276                case 1:
277                   if ((0x100002600L & l) != 0L)
278                   {
279                      if (kind > 48)
280                         kind = 48;
281                      jjCheckNAdd(0);
282                   }
283                   else if ((0x400001000000000L & l) != 0L)
284                   {
285                      if (kind > 49)
286                         kind = 49;
287                      jjCheckNAdd(2);
288                   }
289                   break;
290                case 0:
291                   if ((0x100002600L & l) == 0L)
292                      break;
293                   kind = 48;
294                   jjCheckNAdd(0);
295                   break;
296                case 2:
297                   if ((0x7ff601000000000L & l) == 0L)
298                      break;
299                   if (kind > 49)
300                      kind = 49;
301                   jjCheckNAdd(2);
302                   break;
303                default : break;
304             }
305          } while(i != startsAt);
306       }
307       else if (curChar < 128)
308       {
309          long l = 1L << (curChar & 077);
310          MatchLoop: do
311          {
312             switch(jjstateSet[--i])
313             {
314                case 1:
315                case 2:
316                   if ((0x7fffffe87fffffeL & l) == 0L)
317                      break;
318                   if (kind > 49)
319                      kind = 49;
320                   jjCheckNAdd(2);
321                   break;
322                default : break;
323             }
324          } while(i != startsAt);
325       }
326       else
327       {
328          int i2 = (curChar & 0xff) >> 6;
329          long l2 = 1L << (curChar & 077);
330          MatchLoop: do
331          {
332             switch(jjstateSet[--i])
333             {
334                case 1:
335                case 2:
336                   if ((jjbitVec1[i2] & l2) == 0L)
337                      break;
338                   if (kind > 49)
339                      kind = 49;
340                   jjCheckNAdd(2);
341                   break;
342                default : break;
343             }
344          } while(i != startsAt);
345       }
346       if (kind != 0x7fffffff)
347       {
348          jjmatchedKind = kind;
349          jjmatchedPos = curPos;
350          kind = 0x7fffffff;
351       }
352       ++curPos;
353       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
354          return curPos;
355       try { curChar = input_stream.readChar(); }
356       catch(java.io.IOException e) { return curPos; }
357    }
358 }
359 private final int jjMoveStringLiteralDfa0_3()
360 {
361    return jjMoveNfa_3(0, 0);
362 }
363 private final int jjMoveNfa_3(int startState, int curPos)
364 {
365    int[] nextStates;
366    int startsAt = 0;
367    jjnewStateCnt = 2;
368    int i = 1;
369    jjstateSet[0] = startState;
370    int j, kind = 0x7fffffff;
371    for (;;)
372    {
373       if (++jjround == 0x7fffffff)
374          ReInitRounds();
375       if (curChar < 64)
376       {
377          long l = 1L << curChar;
378          MatchLoop: do
379          {
380             switch(jjstateSet[--i])
381             {
382                case 0:
383                   if (curChar != 36)
384                      break;
385                   if (kind > 56)
386                      kind = 56;
387                   jjCheckNAdd(1);
388                   break;
389                case 1:
390                   if ((0x7ff601000000000L & l) == 0L)
391                      break;
392                   if (kind > 56)
393                      kind = 56;
394                   jjCheckNAdd(1);
395                   break;
396                default : break;
397             }
398          } while(i != startsAt);
399       }
400       else if (curChar < 128)
401       {
402          long l = 1L << (curChar & 077);
403          MatchLoop: do
404          {
405             switch(jjstateSet[--i])
406             {
407                case 0:
408                case 1:
409                   if ((0x7fffffe87fffffeL & l) == 0L)
410                      break;
411                   if (kind > 56)
412                      kind = 56;
413                   jjCheckNAdd(1);
414                   break;
415                default : break;
416             }
417          } while(i != startsAt);
418       }
419       else
420       {
421          int i2 = (curChar & 0xff) >> 6;
422          long l2 = 1L << (curChar & 077);
423          MatchLoop: do
424          {
425             switch(jjstateSet[--i])
426             {
427                case 0:
428                case 1:
429                   if ((jjbitVec1[i2] & l2) == 0L)
430                      break;
431                   if (kind > 56)
432                      kind = 56;
433                   jjCheckNAdd(1);
434                   break;
435                default : break;
436             }
437          } while(i != startsAt);
438       }
439       if (kind != 0x7fffffff)
440       {
441          jjmatchedKind = kind;
442          jjmatchedPos = curPos;
443          kind = 0x7fffffff;
444       }
445       ++curPos;
446       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
447          return curPos;
448       try { curChar = input_stream.readChar(); }
449       catch(java.io.IOException e) { return curPos; }
450    }
451 }
452 private final int jjMoveStringLiteralDfa0_0()
453 {
454    return jjMoveNfa_0(0, 0);
455 }
456 private final int jjMoveNfa_0(int startState, int curPos)
457 {
458    int[] nextStates;
459    int startsAt = 0;
460    jjnewStateCnt = 5;
461    int i = 1;
462    jjstateSet[0] = startState;
463    int j, kind = 0x7fffffff;
464    for (;;)
465    {
466       if (++jjround == 0x7fffffff)
467          ReInitRounds();
468       if (curChar < 64)
469       {
470          long l = 1L << curChar;
471          MatchLoop: do
472          {
473             switch(jjstateSet[--i])
474             {
475                case 0:
476                   if (curChar == 45)
477                      jjAddStates(0, 1);
478                   break;
479                case 1:
480                   if (curChar == 45)
481                      jjCheckNAddTwoStates(2, 3);
482                   break;
483                case 2:
484                   if (curChar == 32)
485                      jjCheckNAddTwoStates(2, 3);
486                   break;
487                case 3:
488                case 4:
489                   if (curChar == 62 && kind > 75)
490                      kind = 75;
491                   break;
492                default : break;
493             }
494          } while(i != startsAt);
495       }
496       else if (curChar < 128)
497       {
498          long l = 1L << (curChar & 077);
499          MatchLoop: do
500          {
501             switch(jjstateSet[--i])
502             {
503                default : break;
504             }
505          } while(i != startsAt);
506       }
507       else
508       {
509          int i2 = (curChar & 0xff) >> 6;
510          long l2 = 1L << (curChar & 077);
511          MatchLoop: do
512          {
513             switch(jjstateSet[--i])
514             {
515                default : break;
516             }
517          } while(i != startsAt);
518       }
519       if (kind != 0x7fffffff)
520       {
521          jjmatchedKind = kind;
522          jjmatchedPos = curPos;
523          kind = 0x7fffffff;
524       }
525       ++curPos;
526       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
527          return curPos;
528       try { curChar = input_stream.readChar(); }
529       catch(java.io.IOException e) { return curPos; }
530    }
531 }
532 private final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
533 {
534    switch (pos)
535    {
536       default :
537          return -1;
538    }
539 }
540 private final int jjStartNfa_2(int pos, long active0, long active1)
541 {
542    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
543 }
544 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
545 {
546    jjmatchedKind = kind;
547    jjmatchedPos = pos;
548    try { curChar = input_stream.readChar(); }
549    catch(java.io.IOException e) { return pos + 1; }
550    return jjMoveNfa_2(state, pos + 1);
551 }
552 private final int jjMoveStringLiteralDfa0_2()
553 {
554    switch(curChar)
555    {
556       case 39:
557          return jjStopAtPos(0, 69);
558       default :
559          return jjMoveNfa_2(9, 0);
560    }
561 }
562 private final int jjMoveNfa_2(int startState, int curPos)
563 {
564    int[] nextStates;
565    int startsAt = 0;
566    jjnewStateCnt = 37;
567    int i = 1;
568    jjstateSet[0] = startState;
569    int j, kind = 0x7fffffff;
570    for (;;)
571    {
572       if (++jjround == 0x7fffffff)
573          ReInitRounds();
574       if (curChar < 64)
575       {
576          long l = 1L << curChar;
577          MatchLoop: do
578          {
579             switch(jjstateSet[--i])
580             {
581                case 9:
582                   if ((0xffffff67ffffffffL & l) != 0L)
583                   {
584                      if (kind > 70)
585                         kind = 70;
586                      jjCheckNAddStates(2, 4);
587                   }
588                   else if ((0x1800000000L & l) != 0L)
589                      jjCheckNAddTwoStates(30, 36);
590                   if (curChar == 60)
591                      jjstateSet[jjnewStateCnt++] = 26;
592                   else if (curChar == 35)
593                      jjstateSet[jjnewStateCnt++] = 10;
594                   else if (curChar == 36)
595                      jjstateSet[jjnewStateCnt++] = 0;
596                   break;
597                case 1:
598                   if ((0xffffff7bffffffffL & l) != 0L)
599                      jjCheckNAddStates(5, 8);
600                   break;
601                case 2:
602                   if (curChar == 34)
603                      jjCheckNAddTwoStates(3, 4);
604                   break;
605                case 3:
606                   if ((0xfffffffbffffffffL & l) != 0L)
607                      jjCheckNAddTwoStates(3, 4);
608                   break;
609                case 4:
610                   if (curChar == 34)
611                      jjCheckNAddStates(5, 8);
612                   break;
613                case 5:
614                   if (curChar == 39)
615                      jjCheckNAddTwoStates(6, 7);
616                   break;
617                case 6:
618                   if ((0xffffff7fffffffffL & l) != 0L)
619                      jjCheckNAddTwoStates(6, 7);
620                   break;
621                case 7:
622                   if (curChar == 39)
623                      jjCheckNAddStates(5, 8);
624                   break;
625                case 11:
626                   if ((0xffffff7bffffffffL & l) != 0L)
627                      jjCheckNAddStates(9, 12);
628                   break;
629                case 12:
630                   if (curChar == 34)
631                      jjCheckNAddTwoStates(13, 14);
632                   break;
633                case 13:
634                   if ((0xfffffffbffffffffL & l) != 0L)
635                      jjCheckNAddTwoStates(13, 14);
636                   break;
637                case 14:
638                   if (curChar == 34)
639                      jjCheckNAddStates(9, 12);
640                   break;
641                case 15:
642                   if (curChar == 39)
643                      jjCheckNAddTwoStates(16, 17);
644                   break;
645                case 16:
646                   if ((0xffffff7fffffffffL & l) != 0L)
647                      jjCheckNAddTwoStates(16, 17);
648                   break;
649                case 17:
650                   if (curChar == 39)
651                      jjCheckNAddStates(9, 12);
652                   break;
653                case 19:
654                   if (curChar == 35)
655                      jjstateSet[jjnewStateCnt++] = 10;
656                   break;
657                case 20:
658                   if (curChar == 61)
659                      jjCheckNAddTwoStates(21, 22);
660                   break;
661                case 21:
662                   if ((0xffffffdfffffffffL & l) != 0L)
663                      jjCheckNAddStates(13, 15);
664                   break;
665                case 22:
666                   if (curChar == 37)
667                      jjstateSet[jjnewStateCnt++] = 23;
668                   break;
669                case 23:
670                   if ((0xbfffffffffffffffL & l) != 0L)
671                      jjCheckNAddStates(13, 15);
672                   break;
673                case 24:
674                   if (curChar == 62 && kind > 68)
675                      kind = 68;
676                   break;
677                case 25:
678                   if (curChar == 37)
679                      jjstateSet[jjnewStateCnt++] = 24;
680                   break;
681                case 26:
682                   if (curChar == 37)
683                      jjstateSet[jjnewStateCnt++] = 20;
684                   break;
685                case 27:
686                   if (curChar == 60)
687                      jjstateSet[jjnewStateCnt++] = 26;
688                   break;
689                case 28:
690                   if ((0xffffff67ffffffffL & l) == 0L)
691                      break;
692                   if (kind > 70)
693                      kind = 70;
694                   jjCheckNAddStates(2, 4);
695                   break;
696                case 29:
697                   if ((0x1800000000L & l) != 0L)
698                      jjCheckNAdd(30);
699                   break;
700                case 30:
701                   if ((0xffffff7fffffffffL & l) == 0L)
702                      break;
703                   if (kind > 70)
704                      kind = 70;
705                   jjCheckNAddStates(2, 4);
706                   break;
707                case 33:
708                   if (curChar == 35)
709                      jjCheckNAdd(32);
710                   break;
711                case 34:
712                   if (curChar == 36)
713                      jjCheckNAdd(32);
714                   break;
715                case 35:
716                   if ((0x1800000000L & l) != 0L)
717                      jjCheckNAddTwoStates(30, 36);
718                   break;
719                case 36:
720                   if (curChar == 39 && kind > 71)
721                      kind = 71;
722                   break;
723                default : break;
724             }
725          } while(i != startsAt);
726       }
727       else if (curChar < 128)
728       {
729          long l = 1L << (curChar & 077);
730          MatchLoop: do
731          {
732             switch(jjstateSet[--i])
733             {
734                case 9:
735                   if (kind > 70)
736                      kind = 70;
737                   jjCheckNAddStates(2, 4);
738                   if (curChar == 92)
739                      jjAddStates(16, 17);
740                   break;
741                case 0:
742                   if (curChar == 123)
743                      jjCheckNAddStates(5, 8);
744                   break;
745                case 1:
746                   if ((0xdfffffffffffffffL & l) != 0L)
747                      jjCheckNAddStates(5, 8);
748                   break;
749                case 3:
750                   jjAddStates(18, 19);
751                   break;
752                case 6:
753                   jjAddStates(20, 21);
754                   break;
755                case 8:
756                   if (curChar == 125 && kind > 66)
757                      kind = 66;
758                   break;
759                case 10:
760                   if (curChar == 123)
761                      jjCheckNAddStates(9, 12);
762                   break;
763                case 11:
764                   if ((0xdfffffffffffffffL & l) != 0L)
765                      jjCheckNAddStates(9, 12);
766                   break;
767                case 13:
768                   jjAddStates(22, 23);
769                   break;
770                case 16:
771                   jjAddStates(24, 25);
772                   break;
773                case 18:
774                   if (curChar == 125 && kind > 67)
775                      kind = 67;
776                   break;
777                case 21:
778                case 23:
779                   jjCheckNAddStates(13, 15);
780                   break;
781                case 28:
782                   if (kind > 70)
783                      kind = 70;
784                   jjCheckNAddStates(2, 4);
785                   break;
786                case 30:
787                   if ((0xf7ffffffffffffffL & l) == 0L)
788                      break;
789                   if (kind > 70)
790                      kind = 70;
791                   jjCheckNAddStates(2, 4);
792                   break;
793                case 31:
794                   if (curChar == 92)
795                      jjAddStates(16, 17);
796                   break;
797                case 32:
798                   if (curChar != 123)
799                      break;
800                   if (kind > 70)
801                      kind = 70;
802                   jjCheckNAddStates(2, 4);
803                   break;
804                default : break;
805             }
806          } while(i != startsAt);
807       }
808       else
809       {
810          int i2 = (curChar & 0xff) >> 6;
811          long l2 = 1L << (curChar & 077);
812          MatchLoop: do
813          {
814             switch(jjstateSet[--i])
815             {
816                case 9:
817                case 28:
818                case 30:
819                   if ((jjbitVec0[i2] & l2) == 0L)
820                      break;
821                   if (kind > 70)
822                      kind = 70;
823                   jjCheckNAddStates(2, 4);
824                   break;
825                case 1:
826                   if ((jjbitVec0[i2] & l2) != 0L)
827                      jjAddStates(5, 8);
828                   break;
829                case 3:
830                   if ((jjbitVec0[i2] & l2) != 0L)
831                      jjAddStates(18, 19);
832                   break;
833                case 6:
834                   if ((jjbitVec0[i2] & l2) != 0L)
835                      jjAddStates(20, 21);
836                   break;
837                case 11:
838                   if ((jjbitVec0[i2] & l2) != 0L)
839                      jjAddStates(9, 12);
840                   break;
841                case 13:
842                   if ((jjbitVec0[i2] & l2) != 0L)
843                      jjAddStates(22, 23);
844                   break;
845                case 16:
846                   if ((jjbitVec0[i2] & l2) != 0L)
847                      jjAddStates(24, 25);
848                   break;
849                case 21:
850                case 23:
851                   if ((jjbitVec0[i2] & l2) != 0L)
852                      jjCheckNAddStates(13, 15);
853                   break;
854                default : break;
855             }
856          } while(i != startsAt);
857       }
858       if (kind != 0x7fffffff)
859       {
860          jjmatchedKind = kind;
861          jjmatchedPos = curPos;
862          kind = 0x7fffffff;
863       }
864       ++curPos;
865       if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
866          return curPos;
867       try { curChar = input_stream.readChar(); }
868       catch(java.io.IOException e) { return curPos; }
869    }
870 }
871 private final int jjStopStringLiteralDfa_7(int pos, long active0)
872 {
873    switch (pos)
874    {
875       case 0:
876          if ((active0 & 0x400000000000L) != 0L)
877             return 3;
878          return -1;
879       case 1:
880          if ((active0 & 0x400000000000L) != 0L)
881             return 4;
882          return -1;
883       case 2:
884          if ((active0 & 0x400000000000L) != 0L)
885             return 6;
886          return -1;
887       default :
888          return -1;
889    }
890 }
891 private final int jjStartNfa_7(int pos, long active0)
892 {
893    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
894 }
895 private final int jjStartNfaWithStates_7(int pos, int kind, int state)
896 {
897    jjmatchedKind = kind;
898    jjmatchedPos = pos;
899    try { curChar = input_stream.readChar(); }
900    catch(java.io.IOException e) { return pos + 1; }
901    return jjMoveNfa_7(state, pos + 1);
902 }
903 private final int jjMoveStringLiteralDfa0_7()
904 {
905    switch(curChar)
906    {
907       case 45:
908          return jjMoveStringLiteralDfa1_7(0x400000000000L);
909       default :
910          return jjMoveNfa_7(8, 0);
911    }
912 }
913 private final int jjMoveStringLiteralDfa1_7(long active0)
914 {
915    try { curChar = input_stream.readChar(); }
916    catch(java.io.IOException e) {
917       jjStopStringLiteralDfa_7(0, active0);
918       return 1;
919    }
920    switch(curChar)
921    {
922       case 45:
923          return jjMoveStringLiteralDfa2_7(active0, 0x400000000000L);
924       default :
925          break;
926    }
927    return jjStartNfa_7(0, active0);
928 }
929 private final int jjMoveStringLiteralDfa2_7(long old0, long active0)
930 {
931    if (((active0 &= old0)) == 0L)
932       return jjStartNfa_7(0, old0); 
933    try { curChar = input_stream.readChar(); }
934    catch(java.io.IOException e) {
935       jjStopStringLiteralDfa_7(1, active0);
936       return 2;
937    }
938    switch(curChar)
939    {
940       case 37:
941          return jjMoveStringLiteralDfa3_7(active0, 0x400000000000L);
942       default :
943          break;
944    }
945    return jjStartNfa_7(1, active0);
946 }
947 private final int jjMoveStringLiteralDfa3_7(long old0, long active0)
948 {
949    if (((active0 &= old0)) == 0L)
950       return jjStartNfa_7(1, old0); 
951    try { curChar = input_stream.readChar(); }
952    catch(java.io.IOException e) {
953       jjStopStringLiteralDfa_7(2, active0);
954       return 3;
955    }
956    switch(curChar)
957    {
958       case 62:
959          if ((active0 & 0x400000000000L) != 0L)
960             return jjStopAtPos(3, 46);
961          break;
962       default :
963          break;
964    }
965    return jjStartNfa_7(2, active0);
966 }
967 private final int jjMoveNfa_7(int startState, int curPos)
968 {
969    int[] nextStates;
970    int startsAt = 0;
971    jjnewStateCnt = 8;
972    int i = 1;
973    jjstateSet[0] = startState;
974    int j, kind = 0x7fffffff;
975    for (;;)
976    {
977       if (++jjround == 0x7fffffff)
978          ReInitRounds();
979       if (curChar < 64)
980       {
981          long l = 1L << curChar;
982          MatchLoop: do
983          {
984             switch(jjstateSet[--i])
985             {
986                case 4:
987                   if ((0xffffffdfffffffffL & l) != 0L)
988                   {
989                      if (kind > 47)
990                         kind = 47;
991                      jjCheckNAddStates(26, 28);
992                   }
993                   else if (curChar == 37)
994                      jjstateSet[jjnewStateCnt++] = 6;
995                   break;
996                case 3:
997                   if ((0xffffdfffffffffffL & l) != 0L)
998                   {
999                      if (kind > 47)
1000                         kind = 47;
1001                      jjCheckNAddStates(26, 28);
1002                   }
1003                   else if (curChar == 45)
1004                      jjstateSet[jjnewStateCnt++] = 5;
1005                   if (curChar == 45)
1006                      jjstateSet[jjnewStateCnt++] = 4;
1007                   break;
1008                case 8:
1009                   if ((0xffffdfffffffffffL & l) != 0L)
1010                   {
1011                      if (kind > 47)
1012                         kind = 47;
1013                      jjCheckNAddStates(26, 28);
1014                   }
1015                   else if (curChar == 45)
1016                      jjAddStates(29, 30);
1017                   if (curChar == 45)
1018                      jjCheckNAdd(0);
1019                   break;
1020                case 0:
1021                   if ((0xffffdfffffffffffL & l) == 0L)
1022                      break;
1023                   if (kind > 47)
1024                      kind = 47;
1025                   jjCheckNAddStates(26, 28);
1026                   break;
1027                case 1:
1028                   if (curChar == 45)
1029                      jjCheckNAdd(0);
1030                   break;
1031                case 2:
1032                   if (curChar == 45)
1033                      jjAddStates(29, 30);
1034                   break;
1035                case 5:
1036                   if (curChar == 37)
1037                      jjstateSet[jjnewStateCnt++] = 6;
1038                   break;
1039                case 6:
1040                   if ((0xbfffffffffffffffL & l) == 0L)
1041                      break;
1042                   if (kind > 47)
1043                      kind = 47;
1044                   jjCheckNAddStates(26, 28);
1045                   break;
1046                case 7:
1047                   if (curChar == 45)
1048                      jjstateSet[jjnewStateCnt++] = 5;
1049                   break;
1050                default : break;
1051             }
1052          } while(i != startsAt);
1053       }
1054       else if (curChar < 128)
1055       {
1056          long l = 1L << (curChar & 077);
1057          MatchLoop: do
1058          {
1059             switch(jjstateSet[--i])
1060             {
1061                case 4:
1062                case 6:
1063                   if (kind > 47)
1064                      kind = 47;
1065                   jjCheckNAddStates(26, 28);
1066                   break;
1067                case 3:
1068                case 0:
1069                   if (kind > 47)
1070                      kind = 47;
1071                   jjCheckNAddStates(26, 28);
1072                   break;
1073                case 8:
1074                   if (kind > 47)
1075                      kind = 47;
1076                   jjCheckNAddStates(26, 28);
1077                   break;
1078                default : break;
1079             }
1080          } while(i != startsAt);
1081       }
1082       else
1083       {
1084          int i2 = (curChar & 0xff) >> 6;
1085          long l2 = 1L << (curChar & 077);
1086          MatchLoop: do
1087          {
1088             switch(jjstateSet[--i])
1089             {
1090                case 4:
1091                case 6:
1092                   if ((jjbitVec0[i2] & l2) == 0L)
1093                      break;
1094                   if (kind > 47)
1095                      kind = 47;
1096                   jjCheckNAddStates(26, 28);
1097                   break;
1098                case 3:
1099                case 0:
1100                   if ((jjbitVec0[i2] & l2) == 0L)
1101                      break;
1102                   if (kind > 47)
1103                      kind = 47;
1104                   jjCheckNAddStates(26, 28);
1105                   break;
1106                case 8:
1107                   if ((jjbitVec0[i2] & l2) == 0L)
1108                      break;
1109                   if (kind > 47)
1110                      kind = 47;
1111                   jjCheckNAddStates(26, 28);
1112                   break;
1113                default : break;
1114             }
1115          } while(i != startsAt);
1116       }
1117       if (kind != 0x7fffffff)
1118       {
1119          jjmatchedKind = kind;
1120          jjmatchedPos = curPos;
1121          kind = 0x7fffffff;
1122       }
1123       ++curPos;
1124       if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1125          return curPos;
1126       try { curChar = input_stream.readChar(); }
1127       catch(java.io.IOException e) { return curPos; }
1128    }
1129 }
1130 private final int jjStopStringLiteralDfa_13(int pos, long active0, long active1)
1131 {
1132    switch (pos)
1133    {
1134       default :
1135          return -1;
1136    }
1137 }
1138 private final int jjStartNfa_13(int pos, long active0, long active1)
1139 {
1140    return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0, active1), pos + 1);
1141 }
1142 private final int jjStartNfaWithStates_13(int pos, int kind, int state)
1143 {
1144    jjmatchedKind = kind;
1145    jjmatchedPos = pos;
1146    try { curChar = input_stream.readChar(); }
1147    catch(java.io.IOException e) { return pos + 1; }
1148    return jjMoveNfa_13(state, pos + 1);
1149 }
1150 private final int jjMoveStringLiteralDfa0_13()
1151 {
1152    switch(curChar)
1153    {
1154       case 34:
1155          return jjStopAtPos(0, 65);
1156       case 39:
1157          return jjStopAtPos(0, 64);
1158       default :
1159          return jjMoveNfa_13(0, 0);
1160    }
1161 }
1162 private final int jjMoveNfa_13(int startState, int curPos)
1163 {
1164    int[] nextStates;
1165    int startsAt = 0;
1166    jjnewStateCnt = 1;
1167    int i = 1;
1168    jjstateSet[0] = startState;
1169    int j, kind = 0x7fffffff;
1170    for (;;)
1171    {
1172       if (++jjround == 0x7fffffff)
1173          ReInitRounds();
1174       if (curChar < 64)
1175       {
1176          long l = 1L << curChar;
1177          MatchLoop: do
1178          {
1179             switch(jjstateSet[--i])
1180             {
1181                case 0:
1182                   if ((0x100002600L & l) == 0L)
1183                      break;
1184                   kind = 21;
1185                   jjstateSet[jjnewStateCnt++] = 0;
1186                   break;
1187                default : break;
1188             }
1189          } while(i != startsAt);
1190       }
1191       else if (curChar < 128)
1192       {
1193          long l = 1L << (curChar & 077);
1194          MatchLoop: do
1195          {
1196             switch(jjstateSet[--i])
1197             {
1198                default : break;
1199             }
1200          } while(i != startsAt);
1201       }
1202       else
1203       {
1204          int i2 = (curChar & 0xff) >> 6;
1205          long l2 = 1L << (curChar & 077);
1206          MatchLoop: do
1207          {
1208             switch(jjstateSet[--i])
1209             {
1210                default : break;
1211             }
1212          } while(i != startsAt);
1213       }
1214       if (kind != 0x7fffffff)
1215       {
1216          jjmatchedKind = kind;
1217          jjmatchedPos = curPos;
1218          kind = 0x7fffffff;
1219       }
1220       ++curPos;
1221       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1222          return curPos;
1223       try { curChar = input_stream.readChar(); }
1224       catch(java.io.IOException e) { return curPos; }
1225    }
1226 }
1227 private final int jjStopStringLiteralDfa_16(int pos, long active0)
1228 {
1229    switch (pos)
1230    {
1231       default :
1232          return -1;
1233    }
1234 }
1235 private final int jjStartNfa_16(int pos, long active0)
1236 {
1237    return jjMoveNfa_16(jjStopStringLiteralDfa_16(pos, active0), pos + 1);
1238 }
1239 private final int jjStartNfaWithStates_16(int pos, int kind, int state)
1240 {
1241    jjmatchedKind = kind;
1242    jjmatchedPos = pos;
1243    try { curChar = input_stream.readChar(); }
1244    catch(java.io.IOException e) { return pos + 1; }
1245    return jjMoveNfa_16(state, pos + 1);
1246 }
1247 private final int jjMoveStringLiteralDfa0_16()
1248 {
1249    switch(curChar)
1250    {
1251       case 60:
1252          jjmatchedKind = 22;
1253          return jjMoveStringLiteralDfa1_16(0x1ff800000L);
1254       default :
1255          return jjMoveNfa_16(0, 0);
1256    }
1257 }
1258 private final int jjMoveStringLiteralDfa1_16(long active0)
1259 {
1260    try { curChar = input_stream.readChar(); }
1261    catch(java.io.IOException e) {
1262       jjStopStringLiteralDfa_16(0, active0);
1263       return 1;
1264    }
1265    switch(curChar)
1266    {
1267       case 33:
1268          return jjMoveStringLiteralDfa2_16(active0, 0xd000000L);
1269       case 37:
1270          if ((active0 & 0x80000000L) != 0L)
1271          {
1272             jjmatchedKind = 31;
1273             jjmatchedPos = 1;
1274          }
1275          return jjMoveStringLiteralDfa2_16(active0, 0x170000000L);
1276       case 47:
1277          if ((active0 & 0x800000L) != 0L)
1278             return jjStopAtPos(1, 23);
1279          break;
1280       case 63:
1281          if ((active0 & 0x2000000L) != 0L)
1282             return jjStopAtPos(1, 25);
1283          break;
1284       default :
1285          break;
1286    }
1287    return jjStartNfa_16(0, active0);
1288 }
1289 private final int jjMoveStringLiteralDfa2_16(long old0, long active0)
1290 {
1291    if (((active0 &= old0)) == 0L)
1292       return jjStartNfa_16(0, old0); 
1293    try { curChar = input_stream.readChar(); }
1294    catch(java.io.IOException e) {
1295       jjStopStringLiteralDfa_16(1, active0);
1296       return 2;
1297    }
1298    switch(curChar)
1299    {
1300       case 33:
1301          if ((active0 & 0x20000000L) != 0L)
1302             return jjStopAtPos(2, 29);
1303          break;
1304       case 45:
1305          return jjMoveStringLiteralDfa3_16(active0, 0x11000000L);
1306       case 61:
1307          if ((active0 & 0x40000000L) != 0L)
1308             return jjStopAtPos(2, 30);
1309          break;
1310       case 64:
1311          if ((active0 & 0x100000000L) != 0L)
1312             return jjStopAtPos(2, 32);
1313          break;
1314       case 91:
1315          return jjMoveStringLiteralDfa3_16(active0, 0x8000000L);
1316       case 68:
1317       case 100:
1318          return jjMoveStringLiteralDfa3_16(active0, 0x4000000L);
1319       default :
1320          break;
1321    }
1322    return jjStartNfa_16(1, active0);
1323 }
1324 private final int jjMoveStringLiteralDfa3_16(long old0, long active0)
1325 {
1326    if (((active0 &= old0)) == 0L)
1327       return jjStartNfa_16(1, old0); 
1328    try { curChar = input_stream.readChar(); }
1329    catch(java.io.IOException e) {
1330       jjStopStringLiteralDfa_16(2, active0);
1331       return 3;
1332    }
1333    switch(curChar)
1334    {
1335       case 45:
1336          if ((active0 & 0x1000000L) != 0L)
1337             return jjStopAtPos(3, 24);
1338          else if ((active0 & 0x10000000L) != 0L)
1339             return jjStopAtPos(3, 28);
1340          break;
1341       case 67:
1342       case 99:
1343          return jjMoveStringLiteralDfa4_16(active0, 0x8000000L);
1344       case 79:
1345       case 111:
1346          return jjMoveStringLiteralDfa4_16(active0, 0x4000000L);
1347       default :
1348          break;
1349    }
1350    return jjStartNfa_16(2, active0);
1351 }
1352 private final int jjMoveStringLiteralDfa4_16(long old0, long active0)
1353 {
1354    if (((active0 &= old0)) == 0L)
1355       return jjStartNfa_16(2, old0); 
1356    try { curChar = input_stream.readChar(); }
1357    catch(java.io.IOException e) {
1358       jjStopStringLiteralDfa_16(3, active0);
1359       return 4;
1360    }
1361    switch(curChar)
1362    {
1363       case 67:
1364       case 99:
1365          return jjMoveStringLiteralDfa5_16(active0, 0x4000000L);
1366       case 68:
1367       case 100:
1368          return jjMoveStringLiteralDfa5_16(active0, 0x8000000L);
1369       default :
1370          break;
1371    }
1372    return jjStartNfa_16(3, active0);
1373 }
1374 private final int jjMoveStringLiteralDfa5_16(long old0, long active0)
1375 {
1376    if (((active0 &= old0)) == 0L)
1377       return jjStartNfa_16(3, old0); 
1378    try { curChar = input_stream.readChar(); }
1379    catch(java.io.IOException e) {
1380       jjStopStringLiteralDfa_16(4, active0);
1381       return 5;
1382    }
1383    switch(curChar)
1384    {
1385       case 65:
1386       case 97:
1387          return jjMoveStringLiteralDfa6_16(active0, 0x8000000L);
1388       case 84:
1389       case 116:
1390          return jjMoveStringLiteralDfa6_16(active0, 0x4000000L);
1391       default :
1392          break;
1393    }
1394    return jjStartNfa_16(4, active0);
1395 }
1396 private final int jjMoveStringLiteralDfa6_16(long old0, long active0)
1397 {
1398    if (((active0 &= old0)) == 0L)
1399       return jjStartNfa_16(4, old0); 
1400    try { curChar = input_stream.readChar(); }
1401    catch(java.io.IOException e) {
1402       jjStopStringLiteralDfa_16(5, active0);
1403       return 6;
1404    }
1405    switch(curChar)
1406    {
1407       case 84:
1408       case 116:
1409          return jjMoveStringLiteralDfa7_16(active0, 0x8000000L);
1410       case 89:
1411       case 121:
1412          return jjMoveStringLiteralDfa7_16(active0, 0x4000000L);
1413       default :
1414          break;
1415    }
1416    return jjStartNfa_16(5, active0);
1417 }
1418 private final int jjMoveStringLiteralDfa7_16(long old0, long active0)
1419 {
1420    if (((active0 &= old0)) == 0L)
1421       return jjStartNfa_16(5, old0); 
1422    try { curChar = input_stream.readChar(); }
1423    catch(java.io.IOException e) {
1424       jjStopStringLiteralDfa_16(6, active0);
1425       return 7;
1426    }
1427    switch(curChar)
1428    {
1429       case 65:
1430       case 97:
1431          return jjMoveStringLiteralDfa8_16(active0, 0x8000000L);
1432       case 80:
1433       case 112:
1434          return jjMoveStringLiteralDfa8_16(active0, 0x4000000L);
1435       default :
1436          break;
1437    }
1438    return jjStartNfa_16(6, active0);
1439 }
1440 private final int jjMoveStringLiteralDfa8_16(long old0, long active0)
1441 {
1442    if (((active0 &= old0)) == 0L)
1443       return jjStartNfa_16(6, old0); 
1444    try { curChar = input_stream.readChar(); }
1445    catch(java.io.IOException e) {
1446       jjStopStringLiteralDfa_16(7, active0);
1447       return 8;
1448    }
1449    switch(curChar)
1450    {
1451       case 91:
1452          if ((active0 & 0x8000000L) != 0L)
1453             return jjStopAtPos(8, 27);
1454          break;
1455       case 69:
1456       case 101:
1457          if ((active0 & 0x4000000L) != 0L)
1458             return jjStopAtPos(8, 26);
1459          break;
1460       default :
1461          break;
1462    }
1463    return jjStartNfa_16(7, active0);
1464 }
1465 private final int jjMoveNfa_16(int startState, int curPos)
1466 {
1467    int[] nextStates;
1468    int startsAt = 0;
1469    jjnewStateCnt = 1;
1470    int i = 1;
1471    jjstateSet[0] = startState;
1472    int j, kind = 0x7fffffff;
1473    for (;;)
1474    {
1475       if (++jjround == 0x7fffffff)
1476          ReInitRounds();
1477       if (curChar < 64)
1478       {
1479          long l = 1L << curChar;
1480          MatchLoop: do
1481          {
1482             switch(jjstateSet[--i])
1483             {
1484                case 0:
1485                   if ((0x100002600L & l) == 0L)
1486                      break;
1487                   kind = 20;
1488                   jjstateSet[jjnewStateCnt++] = 0;
1489                   break;
1490                default : break;
1491             }
1492          } while(i != startsAt);
1493       }
1494       else if (curChar < 128)
1495       {
1496          long l = 1L << (curChar & 077);
1497          MatchLoop: do
1498          {
1499             switch(jjstateSet[--i])
1500             {
1501                default : break;
1502             }
1503          } while(i != startsAt);
1504       }
1505       else
1506       {
1507          int i2 = (curChar & 0xff) >> 6;
1508          long l2 = 1L << (curChar & 077);
1509          MatchLoop: do
1510          {
1511             switch(jjstateSet[--i])
1512             {
1513                default : break;
1514             }
1515          } while(i != startsAt);
1516       }
1517       if (kind != 0x7fffffff)
1518       {
1519          jjmatchedKind = kind;
1520          jjmatchedPos = curPos;
1521          kind = 0x7fffffff;
1522       }
1523       ++curPos;
1524       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
1525          return curPos;
1526       try { curChar = input_stream.readChar(); }
1527       catch(java.io.IOException e) { return curPos; }
1528    }
1529 }
1530 private final int jjStopStringLiteralDfa_12(int pos, long active0)
1531 {
1532    switch (pos)
1533    {
1534       default :
1535          return -1;
1536    }
1537 }
1538 private final int jjStartNfa_12(int pos, long active0)
1539 {
1540    return jjMoveNfa_12(jjStopStringLiteralDfa_12(pos, active0), pos + 1);
1541 }
1542 private final int jjStartNfaWithStates_12(int pos, int kind, int state)
1543 {
1544    jjmatchedKind = kind;
1545    jjmatchedPos = pos;
1546    try { curChar = input_stream.readChar(); }
1547    catch(java.io.IOException e) { return pos + 1; }
1548    return jjMoveNfa_12(state, pos + 1);
1549 }
1550 private final int jjMoveStringLiteralDfa0_12()
1551 {
1552    switch(curChar)
1553    {
1554       case 60:
1555          jjmatchedKind = 22;
1556          return jjMoveStringLiteralDfa1_12(0x1ff800000L);
1557       default :
1558          return jjMoveNfa_12(10, 0);
1559    }
1560 }
1561 private final int jjMoveStringLiteralDfa1_12(long active0)
1562 {
1563    try { curChar = input_stream.readChar(); }
1564    catch(java.io.IOException e) {
1565       jjStopStringLiteralDfa_12(0, active0);
1566       return 1;
1567    }
1568    switch(curChar)
1569    {
1570       case 33:
1571          return jjMoveStringLiteralDfa2_12(active0, 0xd000000L);
1572       case 37:
1573          if ((active0 & 0x80000000L) != 0L)
1574          {
1575             jjmatchedKind = 31;
1576             jjmatchedPos = 1;
1577          }
1578          return jjMoveStringLiteralDfa2_12(active0, 0x170000000L);
1579       case 47:
1580          if ((active0 & 0x800000L) != 0L)
1581             return jjStopAtPos(1, 23);
1582          break;
1583       case 63:
1584          if ((active0 & 0x2000000L) != 0L)
1585             return jjStopAtPos(1, 25);
1586          break;
1587       default :
1588          break;
1589    }
1590    return jjStartNfa_12(0, active0);
1591 }
1592 private final int jjMoveStringLiteralDfa2_12(long old0, long active0)
1593 {
1594    if (((active0 &= old0)) == 0L)
1595       return jjStartNfa_12(0, old0); 
1596    try { curChar = input_stream.readChar(); }
1597    catch(java.io.IOException e) {
1598       jjStopStringLiteralDfa_12(1, active0);
1599       return 2;
1600    }
1601    switch(curChar)
1602    {
1603       case 33:
1604          if ((active0 & 0x20000000L) != 0L)
1605             return jjStopAtPos(2, 29);
1606          break;
1607       case 45:
1608          return jjMoveStringLiteralDfa3_12(active0, 0x11000000L);
1609       case 61:
1610          if ((active0 & 0x40000000L) != 0L)
1611             return jjStopAtPos(2, 30);
1612          break;
1613       case 64:
1614          if ((active0 & 0x100000000L) != 0L)
1615             return jjStopAtPos(2, 32);
1616          break;
1617       case 91:
1618          return jjMoveStringLiteralDfa3_12(active0, 0x8000000L);
1619       case 68:
1620       case 100:
1621          return jjMoveStringLiteralDfa3_12(active0, 0x4000000L);
1622       default :
1623          break;
1624    }
1625    return jjStartNfa_12(1, active0);
1626 }
1627 private final int jjMoveStringLiteralDfa3_12(long old0, long active0)
1628 {
1629    if (((active0 &= old0)) == 0L)
1630       return jjStartNfa_12(1, old0); 
1631    try { curChar = input_stream.readChar(); }
1632    catch(java.io.IOException e) {
1633       jjStopStringLiteralDfa_12(2, active0);
1634       return 3;
1635    }
1636    switch(curChar)
1637    {
1638       case 45:
1639          if ((active0 & 0x1000000L) != 0L)
1640             return jjStopAtPos(3, 24);
1641          else if ((active0 & 0x10000000L) != 0L)
1642             return jjStopAtPos(3, 28);
1643          break;
1644       case 67:
1645       case 99:
1646          return jjMoveStringLiteralDfa4_12(active0, 0x8000000L);
1647       case 79:
1648       case 111:
1649          return jjMoveStringLiteralDfa4_12(active0, 0x4000000L);
1650       default :
1651          break;
1652    }
1653    return jjStartNfa_12(2, active0);
1654 }
1655 private final int jjMoveStringLiteralDfa4_12(long old0, long active0)
1656 {
1657    if (((active0 &= old0)) == 0L)
1658       return jjStartNfa_12(2, old0); 
1659    try { curChar = input_stream.readChar(); }
1660    catch(java.io.IOException e) {
1661       jjStopStringLiteralDfa_12(3, active0);
1662       return 4;
1663    }
1664    switch(curChar)
1665    {
1666       case 67:
1667       case 99:
1668          return jjMoveStringLiteralDfa5_12(active0, 0x4000000L);
1669       case 68:
1670       case 100:
1671          return jjMoveStringLiteralDfa5_12(active0, 0x8000000L);
1672       default :
1673          break;
1674    }
1675    return jjStartNfa_12(3, active0);
1676 }
1677 private final int jjMoveStringLiteralDfa5_12(long old0, long active0)
1678 {
1679    if (((active0 &= old0)) == 0L)
1680       return jjStartNfa_12(3, old0); 
1681    try { curChar = input_stream.readChar(); }
1682    catch(java.io.IOException e) {
1683       jjStopStringLiteralDfa_12(4, active0);
1684       return 5;
1685    }
1686    switch(curChar)
1687    {
1688       case 65:
1689       case 97:
1690          return jjMoveStringLiteralDfa6_12(active0, 0x8000000L);
1691       case 84:
1692       case 116:
1693          return jjMoveStringLiteralDfa6_12(active0, 0x4000000L);
1694       default :
1695          break;
1696    }
1697    return jjStartNfa_12(4, active0);
1698 }
1699 private final int jjMoveStringLiteralDfa6_12(long old0, long active0)
1700 {
1701    if (((active0 &= old0)) == 0L)
1702       return jjStartNfa_12(4, old0); 
1703    try { curChar = input_stream.readChar(); }
1704    catch(java.io.IOException e) {
1705       jjStopStringLiteralDfa_12(5, active0);
1706       return 6;
1707    }
1708    switch(curChar)
1709    {
1710       case 84:
1711       case 116:
1712          return jjMoveStringLiteralDfa7_12(active0, 0x8000000L);
1713       case 89:
1714       case 121:
1715          return jjMoveStringLiteralDfa7_12(active0, 0x4000000L);
1716       default :
1717          break;
1718    }
1719    return jjStartNfa_12(5, active0);
1720 }
1721 private final int jjMoveStringLiteralDfa7_12(long old0, long active0)
1722 {
1723    if (((active0 &= old0)) == 0L)
1724       return jjStartNfa_12(5, old0); 
1725    try { curChar = input_stream.readChar(); }
1726    catch(java.io.IOException e) {
1727       jjStopStringLiteralDfa_12(6, active0);
1728       return 7;
1729    }
1730    switch(curChar)
1731    {
1732       case 65:
1733       case 97:
1734          return jjMoveStringLiteralDfa8_12(active0, 0x8000000L);
1735       case 80:
1736       case 112:
1737          return jjMoveStringLiteralDfa8_12(active0, 0x4000000L);
1738       default :
1739          break;
1740    }
1741    return jjStartNfa_12(6, active0);
1742 }
1743 private final int jjMoveStringLiteralDfa8_12(long old0, long active0)
1744 {
1745    if (((active0 &= old0)) == 0L)
1746       return jjStartNfa_12(6, old0); 
1747    try { curChar = input_stream.readChar(); }
1748    catch(java.io.IOException e) {
1749       jjStopStringLiteralDfa_12(7, active0);
1750       return 8;
1751    }
1752    switch(curChar)
1753    {
1754       case 91:
1755          if ((active0 & 0x8000000L) != 0L)
1756             return jjStopAtPos(8, 27);
1757          break;
1758       case 69:
1759       case 101:
1760          if ((active0 & 0x4000000L) != 0L)
1761             return jjStopAtPos(8, 26);
1762          break;
1763       default :
1764          break;
1765    }
1766    return jjStartNfa_12(7, active0);
1767 }
1768 private final int jjMoveNfa_12(int startState, int curPos)
1769 {
1770    int[] nextStates;
1771    int startsAt = 0;
1772    jjnewStateCnt = 18;
1773    int i = 1;
1774    jjstateSet[0] = startState;
1775    int j, kind = 0x7fffffff;
1776    for (;;)
1777    {
1778       if (++jjround == 0x7fffffff)
1779          ReInitRounds();
1780       if (curChar < 64)
1781       {
1782          long l = 1L << curChar;
1783          MatchLoop: do
1784          {
1785             switch(jjstateSet[--i])
1786             {
1787                case 10:
1788                   if ((0xefffffefffffffffL & l) != 0L)
1789                   {
1790                      if (kind > 34)
1791                         kind = 34;
1792                      jjCheckNAddStates(31, 33);
1793                   }
1794                   else if (curChar == 36)
1795                      jjstateSet[jjnewStateCnt++] = 13;
1796                   if ((0x100002600L & l) != 0L)
1797                   {
1798                      if (kind > 21)
1799                         kind = 21;
1800                      jjCheckNAdd(0);
1801                   }
1802                   else if (curChar == 36)
1803                      jjstateSet[jjnewStateCnt++] = 1;
1804                   break;
1805                case 0:
1806                   if ((0x100002600L & l) == 0L)
1807                      break;
1808                   if (kind > 21)
1809                      kind = 21;
1810                   jjCheckNAdd(0);
1811                   break;
1812                case 2:
1813                   if ((0xffffff7bffffffffL & l) != 0L)
1814                      jjCheckNAddStates(34, 37);
1815                   break;
1816                case 3:
1817                   if (curChar == 34)
1818                      jjCheckNAddTwoStates(4, 5);
1819                   break;
1820                case 4:
1821                   if ((0xfffffffbffffffffL & l) != 0L)
1822                      jjCheckNAddTwoStates(4, 5);
1823                   break;
1824                case 5:
1825                   if (curChar == 34)
1826                      jjCheckNAddStates(34, 37);
1827                   break;
1828                case 6:
1829                   if (curChar == 39)
1830                      jjCheckNAddTwoStates(7, 8);
1831                   break;
1832                case 7:
1833                   if ((0xffffff7fffffffffL & l) != 0L)
1834                      jjCheckNAddTwoStates(7, 8);
1835                   break;
1836                case 8:
1837                   if (curChar == 39)
1838                      jjCheckNAddStates(34, 37);
1839                   break;
1840                case 11:
1841                   if ((0xefffffefffffffffL & l) == 0L)
1842                      break;
1843                   if (kind > 34)
1844                      kind = 34;
1845                   jjCheckNAddStates(31, 33);
1846                   break;
1847                case 12:
1848                   if (curChar == 36)
1849                      jjstateSet[jjnewStateCnt++] = 13;
1850                   break;
1851                case 13:
1852                   if ((0xefffffffffffffffL & l) == 0L)
1853                      break;
1854                   if (kind > 34)
1855                      kind = 34;
1856                   jjCheckNAddStates(31, 33);
1857                   break;
1858                case 16:
1859                   if (curChar == 35)
1860                      jjCheckNAdd(15);
1861                   break;
1862                case 17:
1863                   if (curChar == 36)
1864                      jjCheckNAdd(15);
1865                   break;
1866                default : break;
1867             }
1868          } while(i != startsAt);
1869       }
1870       else if (curChar < 128)
1871       {
1872          long l = 1L << (curChar & 077);
1873          MatchLoop: do
1874          {
1875             switch(jjstateSet[--i])
1876             {
1877                case 10:
1878                   if (kind > 34)
1879                      kind = 34;
1880                   jjCheckNAddStates(31, 33);
1881                   if (curChar == 92)
1882                      jjAddStates(24, 25);
1883                   break;
1884                case 1:
1885                   if (curChar == 123)
1886                      jjCheckNAddStates(34, 37);
1887                   break;
1888                case 2:
1889                   if ((0xdfffffffffffffffL & l) != 0L)
1890                      jjCheckNAddStates(34, 37);
1891                   break;
1892                case 4:
1893                   jjAddStates(38, 39);
1894                   break;
1895                case 7:
1896                   jjAddStates(40, 41);
1897                   break;
1898                case 9:
1899                   if (curChar == 125 && kind > 33)
1900                      kind = 33;
1901                   break;
1902                case 11:
1903                   if (kind > 34)
1904                      kind = 34;
1905                   jjCheckNAddStates(31, 33);
1906                   break;
1907                case 13:
1908                   if ((0xf7ffffffffffffffL & l) == 0L)
1909                      break;
1910                   if (kind > 34)
1911                      kind = 34;
1912                   jjCheckNAddStates(31, 33);
1913                   break;
1914                case 14:
1915                   if (curChar == 92)
1916                      jjAddStates(24, 25);
1917                   break;
1918                case 15:
1919                   if (curChar != 123)
1920                      break;
1921                   if (kind > 34)
1922                      kind = 34;
1923                   jjCheckNAddStates(31, 33);
1924                   break;
1925                default : break;
1926             }
1927          } while(i != startsAt);
1928       }
1929       else
1930       {
1931          int i2 = (curChar & 0xff) >> 6;
1932          long l2 = 1L << (curChar & 077);
1933          MatchLoop: do
1934          {
1935             switch(jjstateSet[--i])
1936             {
1937                case 10:
1938                case 11:
1939                case 13:
1940                   if ((jjbitVec0[i2] & l2) == 0L)
1941                      break;
1942                   if (kind > 34)
1943                      kind = 34;
1944                   jjCheckNAddStates(31, 33);
1945                   break;
1946                case 2:
1947                   if ((jjbitVec0[i2] & l2) != 0L)
1948                      jjAddStates(34, 37);
1949                   break;
1950                case 4:
1951                   if ((jjbitVec0[i2] & l2) != 0L)
1952                      jjAddStates(38, 39);
1953                   break;
1954                case 7:
1955                   if ((jjbitVec0[i2] & l2) != 0L)
1956                      jjAddStates(40, 41);
1957                   break;
1958                default : break;
1959             }
1960          } while(i != startsAt);
1961       }
1962       if (kind != 0x7fffffff)
1963       {
1964          jjmatchedKind = kind;
1965          jjmatchedPos = curPos;
1966          kind = 0x7fffffff;
1967       }
1968       ++curPos;
1969       if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
1970          return curPos;
1971       try { curChar = input_stream.readChar(); }
1972       catch(java.io.IOException e) { return curPos; }
1973    }
1974 }
1975 private final int jjStopStringLiteralDfa_8(int pos, long active0)
1976 {
1977    switch (pos)
1978    {
1979       case 0:
1980          if ((active0 & 0x100000000000L) != 0L)
1981             return 2;
1982          return -1;
1983       default :
1984          return -1;
1985    }
1986 }
1987 private final int jjStartNfa_8(int pos, long active0)
1988 {
1989    return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
1990 }
1991 private final int jjStartNfaWithStates_8(int pos, int kind, int state)
1992 {
1993    jjmatchedKind = kind;
1994    jjmatchedPos = pos;
1995    try { curChar = input_stream.readChar(); }
1996    catch(java.io.IOException e) { return pos + 1; }
1997    return jjMoveNfa_8(state, pos + 1);
1998 }
1999 private final int jjMoveStringLiteralDfa0_8()
2000 {
2001    switch(curChar)
2002    {
2003       case 37:
2004          return jjMoveStringLiteralDfa1_8(0x100000000000L);
2005       default :
2006          return jjMoveNfa_8(3, 0);
2007    }
2008 }
2009 private final int jjMoveStringLiteralDfa1_8(long active0)
2010 {
2011    try { curChar = input_stream.readChar(); }
2012    catch(java.io.IOException e) {
2013       jjStopStringLiteralDfa_8(0, active0);
2014       return 1;
2015    }
2016    switch(curChar)
2017    {
2018       case 62:
2019          if ((active0 & 0x100000000000L) != 0L)
2020             return jjStopAtPos(1, 44);
2021          break;
2022       default :
2023          break;
2024    }
2025    return jjStartNfa_8(0, active0);
2026 }
2027 private final int jjMoveNfa_8(int startState, int curPos)
2028 {
2029    int[] nextStates;
2030    int startsAt = 0;
2031    jjnewStateCnt = 3;
2032    int i = 1;
2033    jjstateSet[0] = startState;
2034    int j, kind = 0x7fffffff;
2035    for (;;)
2036    {
2037       if (++jjround == 0x7fffffff)
2038          ReInitRounds();
2039       if (curChar < 64)
2040       {
2041          long l = 1L << curChar;
2042          MatchLoop: do
2043          {
2044             switch(jjstateSet[--i])
2045             {
2046                case 3:
2047                   if ((0xffffffdfffffffffL & l) != 0L)
2048                   {
2049                      if (kind > 45)
2050                         kind = 45;
2051                      jjCheckNAddTwoStates(0, 1);
2052                   }
2053                   else if (curChar == 37)
2054                      jjstateSet[jjnewStateCnt++] = 2;
2055                   break;
2056                case 0:
2057                   if ((0xffffffdfffffffffL & l) == 0L)
2058                      break;
2059                   if (kind > 45)
2060                      kind = 45;
2061                   jjCheckNAddTwoStates(0, 1);
2062                   break;
2063                case 1:
2064                   if (curChar == 37)
2065                      jjstateSet[jjnewStateCnt++] = 2;
2066                   break;
2067                case 2:
2068                   if ((0xbfffffffffffffffL & l) == 0L)
2069                      break;
2070                   if (kind > 45)
2071                      kind = 45;
2072                   jjCheckNAddTwoStates(0, 1);
2073                   break;
2074                default : break;
2075             }
2076          } while(i != startsAt);
2077       }
2078       else if (curChar < 128)
2079       {
2080          long l = 1L << (curChar & 077);
2081          MatchLoop: do
2082          {
2083             switch(jjstateSet[--i])
2084             {
2085                case 3:
2086                case 0:
2087                case 2:
2088                   if (kind > 45)
2089                      kind = 45;
2090                   jjCheckNAddTwoStates(0, 1);
2091                   break;
2092                default : break;
2093             }
2094          } while(i != startsAt);
2095       }
2096       else
2097       {
2098          int i2 = (curChar & 0xff) >> 6;
2099          long l2 = 1L << (curChar & 077);
2100          MatchLoop: do
2101          {
2102             switch(jjstateSet[--i])
2103             {
2104                case 3:
2105                case 0:
2106                case 2:
2107                   if ((jjbitVec0[i2] & l2) == 0L)
2108                      break;
2109                   if (kind > 45)
2110                      kind = 45;
2111                   jjCheckNAddTwoStates(0, 1);
2112                   break;
2113                default : break;
2114             }
2115          } while(i != startsAt);
2116       }
2117       if (kind != 0x7fffffff)
2118       {
2119          jjmatchedKind = kind;
2120          jjmatchedPos = curPos;
2121          kind = 0x7fffffff;
2122       }
2123       ++curPos;
2124       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2125          return curPos;
2126       try { curChar = input_stream.readChar(); }
2127       catch(java.io.IOException e) { return curPos; }
2128    }
2129 }
2130 private final int jjStopStringLiteralDfa_11(int pos, long active0)
2131 {
2132    switch (pos)
2133    {
2134       default :
2135          return -1;
2136    }
2137 }
2138 private final int jjStartNfa_11(int pos, long active0)
2139 {
2140    return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
2141 }
2142 private final int jjStartNfaWithStates_11(int pos, int kind, int state)
2143 {
2144    jjmatchedKind = kind;
2145    jjmatchedPos = pos;
2146    try { curChar = input_stream.readChar(); }
2147    catch(java.io.IOException e) { return pos + 1; }
2148    return jjMoveNfa_11(state, pos + 1);
2149 }
2150 private final int jjMoveStringLiteralDfa0_11()
2151 {
2152    switch(curChar)
2153    {
2154       case 47:
2155          return jjMoveStringLiteralDfa1_11(0x2000000000000000L);
2156       case 61:
2157          return jjStopAtPos(0, 62);
2158       case 62:
2159          return jjStopAtPos(0, 59);
2160       default :
2161          return jjMoveNfa_11(1, 0);
2162    }
2163 }
2164 private final int jjMoveStringLiteralDfa1_11(long active0)
2165 {
2166    try { curChar = input_stream.readChar(); }
2167    catch(java.io.IOException e) {
2168       jjStopStringLiteralDfa_11(0, active0);
2169       return 1;
2170    }
2171    switch(curChar)
2172    {
2173       case 62:
2174          if ((active0 & 0x2000000000000000L) != 0L)
2175             return jjStopAtPos(1, 61);
2176          break;
2177       default :
2178          break;
2179    }
2180    return jjStartNfa_11(0, active0);
2181 }
2182 private final int jjMoveNfa_11(int startState, int curPos)
2183 {
2184    int[] nextStates;
2185    int startsAt = 0;
2186    jjnewStateCnt = 6;
2187    int i = 1;
2188    jjstateSet[0] = startState;
2189    int j, kind = 0x7fffffff;
2190    for (;;)
2191    {
2192       if (++jjround == 0x7fffffff)
2193          ReInitRounds();
2194       if (curChar < 64)
2195       {
2196          long l = 1L << curChar;
2197          MatchLoop: do
2198          {
2199             switch(jjstateSet[--i])
2200             {
2201                case 1:
2202                   if ((0x100002600L & l) != 0L)
2203                   {
2204                      if (kind > 21)
2205                         kind = 21;
2206                      jjCheckNAdd(0);
2207                   }
2208                   else if (curChar == 33)
2209                      jjCheckNAdd(3);
2210                   else if (curChar == 36)
2211                   {
2212                      if (kind > 58)
2213                         kind = 58;
2214                      jjCheckNAdd(2);
2215                   }
2216                   else if (curChar == 63)
2217                      jjCheckNAdd(3);
2218                   break;
2219                case 0:
2220                   if ((0x100002600L & l) == 0L)
2221                      break;
2222                   kind = 21;
2223                   jjCheckNAdd(0);
2224                   break;
2225                case 2:
2226                   if ((0x7ff601000000000L & l) == 0L)
2227                      break;
2228                   if (kind > 58)
2229                      kind = 58;
2230                   jjCheckNAdd(2);
2231                   break;
2232                case 3:
2233                   if (curChar == 62)
2234                      kind = 60;
2235                   break;
2236                case 4:
2237                   if (curChar == 63)
2238                      jjCheckNAdd(3);
2239                   break;
2240                case 5:
2241                   if (curChar == 33)
2242                      jjCheckNAdd(3);
2243                   break;
2244                default : break;
2245             }
2246          } while(i != startsAt);
2247       }
2248       else if (curChar < 128)
2249       {
2250          long l = 1L << (curChar & 077);
2251          MatchLoop: do
2252          {
2253             switch(jjstateSet[--i])
2254             {
2255                case 1:
2256                case 2:
2257                   if ((0x7fffffe87fffffeL & l) == 0L)
2258                      break;
2259                   if (kind > 58)
2260                      kind = 58;
2261                   jjCheckNAdd(2);
2262                   break;
2263                default : break;
2264             }
2265          } while(i != startsAt);
2266       }
2267       else
2268       {
2269          int i2 = (curChar & 0xff) >> 6;
2270          long l2 = 1L << (curChar & 077);
2271          MatchLoop: do
2272          {
2273             switch(jjstateSet[--i])
2274             {
2275                case 1:
2276                case 2:
2277                   if ((jjbitVec1[i2] & l2) == 0L)
2278                      break;
2279                   if (kind > 58)
2280                      kind = 58;
2281                   jjCheckNAdd(2);
2282                   break;
2283                default : break;
2284             }
2285          } while(i != startsAt);
2286       }
2287       if (kind != 0x7fffffff)
2288       {
2289          jjmatchedKind = kind;
2290          jjmatchedPos = curPos;
2291          kind = 0x7fffffff;
2292       }
2293       ++curPos;
2294       if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
2295          return curPos;
2296       try { curChar = input_stream.readChar(); }
2297       catch(java.io.IOException e) { return curPos; }
2298    }
2299 }
2300 private final int jjMoveStringLiteralDfa0_15()
2301 {
2302    return jjMoveNfa_15(1, 0);
2303 }
2304 private final int jjMoveNfa_15(int startState, int curPos)
2305 {
2306    int[] nextStates;
2307    int startsAt = 0;
2308    jjnewStateCnt = 3;
2309    int i = 1;
2310    jjstateSet[0] = startState;
2311    int j, kind = 0x7fffffff;
2312    for (;;)
2313    {
2314       if (++jjround == 0x7fffffff)
2315          ReInitRounds();
2316       if (curChar < 64)
2317       {
2318          long l = 1L << curChar;
2319          MatchLoop: do
2320          {
2321             switch(jjstateSet[--i])
2322             {
2323                case 1:
2324                   if ((0x100002600L & l) != 0L)
2325                   {
2326                      if (kind > 20)
2327                         kind = 20;
2328                      jjCheckNAdd(0);
2329                   }
2330                   else if (curChar == 36)
2331                   {
2332                      if (kind > 35)
2333                         kind = 35;
2334                      jjCheckNAdd(2);
2335                   }
2336                   break;
2337                case 0:
2338                   if ((0x100002600L & l) == 0L)
2339                      break;
2340                   kind = 20;
2341                   jjCheckNAdd(0);
2342                   break;
2343                case 2:
2344                   if ((0x7ff601000000000L & l) == 0L)
2345                      break;
2346                   if (kind > 35)
2347                      kind = 35;
2348                   jjCheckNAdd(2);
2349                   break;
2350                default : break;
2351             }
2352          } while(i != startsAt);
2353       }
2354       else if (curChar < 128)
2355       {
2356          long l = 1L << (curChar & 077);
2357          MatchLoop: do
2358          {
2359             switch(jjstateSet[--i])
2360             {
2361                case 1:
2362                case 2:
2363                   if ((0x7fffffe87fffffeL & l) == 0L)
2364                      break;
2365                   if (kind > 35)
2366                      kind = 35;
2367                   jjCheckNAdd(2);
2368                   break;
2369                default : break;
2370             }
2371          } while(i != startsAt);
2372       }
2373       else
2374       {
2375          int i2 = (curChar & 0xff) >> 6;
2376          long l2 = 1L << (curChar & 077);
2377          MatchLoop: do
2378          {
2379             switch(jjstateSet[--i])
2380             {
2381                case 1:
2382                case 2:
2383                   if ((jjbitVec1[i2] & l2) == 0L)
2384                      break;
2385                   if (kind > 35)
2386                      kind = 35;
2387                   jjCheckNAdd(2);
2388                   break;
2389                default : break;
2390             }
2391          } while(i != startsAt);
2392       }
2393       if (kind != 0x7fffffff)
2394       {
2395          jjmatchedKind = kind;
2396          jjmatchedPos = curPos;
2397          kind = 0x7fffffff;
2398       }
2399       ++curPos;
2400       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
2401          return curPos;
2402       try { curChar = input_stream.readChar(); }
2403       catch(java.io.IOException e) { return curPos; }
2404    }
2405 }
2406 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
2407 {
2408    switch (pos)
2409    {
2410       default :
2411          return -1;
2412    }
2413 }
2414 private final int jjStartNfa_1(int pos, long active0, long active1)
2415 {
2416    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
2417 }
2418 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
2419 {
2420    jjmatchedKind = kind;
2421    jjmatchedPos = pos;
2422    try { curChar = input_stream.readChar(); }
2423    catch(java.io.IOException e) { return pos + 1; }
2424    return jjMoveNfa_1(state, pos + 1);
2425 }
2426 private final int jjMoveStringLiteralDfa0_1()
2427 {
2428    switch(curChar)
2429    {
2430       case 34:
2431          return jjStopAtPos(0, 72);
2432       default :
2433          return jjMoveNfa_1(9, 0);
2434    }
2435 }
2436 private final int jjMoveNfa_1(int startState, int curPos)
2437 {
2438    int[] nextStates;
2439    int startsAt = 0;
2440    jjnewStateCnt = 37;
2441    int i = 1;
2442    jjstateSet[0] = startState;
2443    int j, kind = 0x7fffffff;
2444    for (;;)
2445    {
2446       if (++jjround == 0x7fffffff)
2447          ReInitRounds();
2448       if (curChar < 64)
2449       {
2450          long l = 1L << curChar;
2451          MatchLoop: do
2452          {
2453             switch(jjstateSet[--i])
2454             {
2455                case 9:
2456                   if ((0xffffffe3ffffffffL & l) != 0L)
2457                   {
2458                      if (kind > 73)
2459                         kind = 73;
2460                      jjCheckNAddStates(2, 4);
2461                   }
2462                   else if ((0x1800000000L & l) != 0L)
2463                      jjCheckNAddTwoStates(30, 36);
2464                   if (curChar == 60)
2465                      jjstateSet[jjnewStateCnt++] = 26;
2466                   else if (curChar == 35)
2467                      jjstateSet[jjnewStateCnt++] = 10;
2468                   else if (curChar == 36)
2469                      jjstateSet[jjnewStateCnt++] = 0;
2470                   break;
2471                case 1:
2472                   if ((0xffffff7bffffffffL & l) != 0L)
2473                      jjCheckNAddStates(5, 8);
2474                   break;
2475                case 2:
2476                   if (curChar == 34)
2477                      jjCheckNAddTwoStates(3, 4);
2478                   break;
2479                case 3:
2480                   if ((0xfffffffbffffffffL & l) != 0L)
2481                      jjCheckNAddTwoStates(3, 4);
2482                   break;
2483                case 4:
2484                   if (curChar == 34)
2485                      jjCheckNAddStates(5, 8);
2486                   break;
2487                case 5:
2488                   if (curChar == 39)
2489                      jjCheckNAddTwoStates(6, 7);
2490                   break;
2491                case 6:
2492                   if ((0xffffff7fffffffffL & l) != 0L)
2493                      jjCheckNAddTwoStates(6, 7);
2494                   break;
2495                case 7:
2496                   if (curChar == 39)
2497                      jjCheckNAddStates(5, 8);
2498                   break;
2499                case 11:
2500                   if ((0xffffff7bffffffffL & l) != 0L)
2501                      jjCheckNAddStates(9, 12);
2502                   break;
2503                case 12:
2504                   if (curChar == 34)
2505                      jjCheckNAddTwoStates(13, 14);
2506                   break;
2507                case 13:
2508                   if ((0xfffffffbffffffffL & l) != 0L)
2509                      jjCheckNAddTwoStates(13, 14);
2510                   break;
2511                case 14:
2512                   if (curChar == 34)
2513                      jjCheckNAddStates(9, 12);
2514                   break;
2515                case 15:
2516                   if (curChar == 39)
2517                      jjCheckNAddTwoStates(16, 17);
2518                   break;
2519                case 16:
2520                   if ((0xffffff7fffffffffL & l) != 0L)
2521                      jjCheckNAddTwoStates(16, 17);
2522                   break;
2523                case 17:
2524                   if (curChar == 39)
2525                      jjCheckNAddStates(9, 12);
2526                   break;
2527                case 19:
2528                   if (curChar == 35)
2529                      jjstateSet[jjnewStateCnt++] = 10;
2530                   break;
2531                case 20:
2532                   if (curChar == 61)
2533                      jjCheckNAddTwoStates(21, 22);
2534                   break;
2535                case 21:
2536                   if ((0xffffffdfffffffffL & l) != 0L)
2537                      jjCheckNAddStates(13, 15);
2538                   break;
2539                case 22:
2540                   if (curChar == 37)
2541                      jjstateSet[jjnewStateCnt++] = 23;
2542                   break;
2543                case 23:
2544                   if ((0xbfffffffffffffffL & l) != 0L)
2545                      jjCheckNAddStates(13, 15);
2546                   break;
2547                case 24:
2548                   if (curChar == 62 && kind > 68)
2549                      kind = 68;
2550                   break;
2551                case 25:
2552                   if (curChar == 37)
2553                      jjstateSet[jjnewStateCnt++] = 24;
2554                   break;
2555                case 26:
2556                   if (curChar == 37)
2557                      jjstateSet[jjnewStateCnt++] = 20;
2558                   break;
2559                case 27:
2560                   if (curChar == 60)
2561                      jjstateSet[jjnewStateCnt++] = 26;
2562                   break;
2563                case 28:
2564                   if ((0xffffffe3ffffffffL & l) == 0L)
2565                      break;
2566                   if (kind > 73)
2567                      kind = 73;
2568                   jjCheckNAddStates(2, 4);
2569                   break;
2570                case 29:
2571                   if ((0x1800000000L & l) != 0L)
2572                      jjCheckNAdd(30);
2573                   break;
2574                case 30:
2575                   if ((0xfffffffbffffffffL & l) == 0L)
2576                      break;
2577                   if (kind > 73)
2578                      kind = 73;
2579                   jjCheckNAddStates(2, 4);
2580                   break;
2581                case 33:
2582                   if (curChar == 35)
2583                      jjCheckNAdd(32);
2584                   break;
2585                case 34:
2586                   if (curChar == 36)
2587                      jjCheckNAdd(32);
2588                   break;
2589                case 35:
2590                   if ((0x1800000000L & l) != 0L)
2591                      jjCheckNAddTwoStates(30, 36);
2592                   break;
2593                case 36:
2594                   if (curChar == 34 && kind > 74)
2595                      kind = 74;
2596                   break;
2597                default : break;
2598             }
2599          } while(i != startsAt);
2600       }
2601       else if (curChar < 128)
2602       {
2603          long l = 1L << (curChar & 077);
2604          MatchLoop: do
2605          {
2606             switch(jjstateSet[--i])
2607             {
2608                case 9:
2609                   if (kind > 73)
2610                      kind = 73;
2611                   jjCheckNAddStates(2, 4);
2612                   if (curChar == 92)
2613                      jjAddStates(16, 17);
2614                   break;
2615                case 0:
2616                   if (curChar == 123)
2617                      jjCheckNAddStates(5, 8);
2618                   break;
2619                case 1:
2620                   if ((0xdfffffffffffffffL & l) != 0L)
2621                      jjCheckNAddStates(5, 8);
2622                   break;
2623                case 3:
2624                   jjAddStates(18, 19);
2625                   break;
2626                case 6:
2627                   jjAddStates(20, 21);
2628                   break;
2629                case 8:
2630                   if (curChar == 125 && kind > 66)
2631                      kind = 66;
2632                   break;
2633                case 10:
2634                   if (curChar == 123)
2635                      jjCheckNAddStates(9, 12);
2636                   break;
2637                case 11:
2638                   if ((0xdfffffffffffffffL & l) != 0L)
2639                      jjCheckNAddStates(9, 12);
2640                   break;
2641                case 13:
2642                   jjAddStates(22, 23);
2643                   break;
2644                case 16:
2645                   jjAddStates(24, 25);
2646                   break;
2647                case 18:
2648                   if (curChar == 125 && kind > 67)
2649                      kind = 67;
2650                   break;
2651                case 21:
2652                case 23:
2653                   jjCheckNAddStates(13, 15);
2654                   break;
2655                case 28:
2656                   if (kind > 73)
2657                      kind = 73;
2658                   jjCheckNAddStates(2, 4);
2659                   break;
2660                case 30:
2661                   if ((0xf7ffffffffffffffL & l) == 0L)
2662                      break;
2663                   if (kind > 73)
2664                      kind = 73;
2665                   jjCheckNAddStates(2, 4);
2666                   break;
2667                case 31:
2668                   if (curChar == 92)
2669                      jjAddStates(16, 17);
2670                   break;
2671                case 32:
2672                   if (curChar != 123)
2673                      break;
2674                   if (kind > 73)
2675                      kind = 73;
2676                   jjCheckNAddStates(2, 4);
2677                   break;
2678                default : break;
2679             }
2680          } while(i != startsAt);
2681       }
2682       else
2683       {
2684          int i2 = (curChar & 0xff) >> 6;
2685          long l2 = 1L << (curChar & 077);
2686          MatchLoop: do
2687          {
2688             switch(jjstateSet[--i])
2689             {
2690                case 9:
2691                case 28:
2692                case 30:
2693                   if ((jjbitVec0[i2] & l2) == 0L)
2694                      break;
2695                   if (kind > 73)
2696                      kind = 73;
2697                   jjCheckNAddStates(2, 4);
2698                   break;
2699                case 1:
2700                   if ((jjbitVec0[i2] & l2) != 0L)
2701                      jjAddStates(5, 8);
2702                   break;
2703                case 3:
2704                   if ((jjbitVec0[i2] & l2) != 0L)
2705                      jjAddStates(18, 19);
2706                   break;
2707                case 6:
2708                   if ((jjbitVec0[i2] & l2) != 0L)
2709                      jjAddStates(20, 21);
2710                   break;
2711                case 11:
2712                   if ((jjbitVec0[i2] & l2) != 0L)
2713                      jjAddStates(9, 12);
2714                   break;
2715                case 13:
2716                   if ((jjbitVec0[i2] & l2) != 0L)
2717                      jjAddStates(22, 23);
2718                   break;
2719                case 16:
2720                   if ((jjbitVec0[i2] & l2) != 0L)
2721                      jjAddStates(24, 25);
2722                   break;
2723                case 21:
2724                case 23:
2725                   if ((jjbitVec0[i2] & l2) != 0L)
2726                      jjCheckNAddStates(13, 15);
2727                   break;
2728                default : break;
2729             }
2730          } while(i != startsAt);
2731       }
2732       if (kind != 0x7fffffff)
2733       {
2734          jjmatchedKind = kind;
2735          jjmatchedPos = curPos;
2736          kind = 0x7fffffff;
2737       }
2738       ++curPos;
2739       if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
2740          return curPos;
2741       try { curChar = input_stream.readChar(); }
2742       catch(java.io.IOException e) { return curPos; }
2743    }
2744 }
2745 private final int jjStopStringLiteralDfa_5(int pos, long active0)
2746 {
2747    switch (pos)
2748    {
2749       default :
2750          return -1;
2751    }
2752 }
2753 private final int jjStartNfa_5(int pos, long active0)
2754 {
2755    return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2756 }
2757 private final int jjStartNfaWithStates_5(int pos, int kind, int state)
2758 {
2759    jjmatchedKind = kind;
2760    jjmatchedPos = pos;
2761    try { curChar = input_stream.readChar(); }
2762    catch(java.io.IOException e) { return pos + 1; }
2763    return jjMoveNfa_5(state, pos + 1);
2764 }
2765 private final int jjMoveStringLiteralDfa0_5()
2766 {
2767    switch(curChar)
2768    {
2769       case 62:
2770          return jjStopAtPos(0, 52);
2771       case 80:
2772       case 112:
2773          return jjMoveStringLiteralDfa1_5(0x4000000000000L);
2774       case 83:
2775       case 115:
2776          return jjMoveStringLiteralDfa1_5(0x8000000000000L);
2777       default :
2778          return jjMoveNfa_5(1, 0);
2779    }
2780 }
2781 private final int jjMoveStringLiteralDfa1_5(long active0)
2782 {
2783    try { curChar = input_stream.readChar(); }
2784    catch(java.io.IOException e) {
2785       jjStopStringLiteralDfa_5(0, active0);
2786       return 1;
2787    }
2788    switch(curChar)
2789    {
2790       case 85:
2791       case 117:
2792          return jjMoveStringLiteralDfa2_5(active0, 0x4000000000000L);
2793       case 89:
2794       case 121:
2795          return jjMoveStringLiteralDfa2_5(active0, 0x8000000000000L);
2796       default :
2797          break;
2798    }
2799    return jjStartNfa_5(0, active0);
2800 }
2801 private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
2802 {
2803    if (((active0 &= old0)) == 0L)
2804       return jjStartNfa_5(0, old0); 
2805    try { curChar = input_stream.readChar(); }
2806    catch(java.io.IOException e) {
2807       jjStopStringLiteralDfa_5(1, active0);
2808       return 2;
2809    }
2810    switch(curChar)
2811    {
2812       case 66:
2813       case 98:
2814          return jjMoveStringLiteralDfa3_5(active0, 0x4000000000000L);
2815       case 83:
2816       case 115:
2817          return jjMoveStringLiteralDfa3_5(active0, 0x8000000000000L);
2818       default :
2819          break;
2820    }
2821    return jjStartNfa_5(1, active0);
2822 }
2823 private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
2824 {
2825    if (((active0 &= old0)) == 0L)
2826       return jjStartNfa_5(1, old0); 
2827    try { curChar = input_stream.readChar(); }
2828    catch(java.io.IOException e) {
2829       jjStopStringLiteralDfa_5(2, active0);
2830       return 3;
2831    }
2832    switch(curChar)
2833    {
2834       case 76:
2835       case 108:
2836          return jjMoveStringLiteralDfa4_5(active0, 0x4000000000000L);
2837       case 84:
2838       case 116:
2839          return jjMoveStringLiteralDfa4_5(active0, 0x8000000000000L);
2840       default :
2841          break;
2842    }
2843    return jjStartNfa_5(2, active0);
2844 }
2845 private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
2846 {
2847    if (((active0 &= old0)) == 0L)
2848       return jjStartNfa_5(2, old0); 
2849    try { curChar = input_stream.readChar(); }
2850    catch(java.io.IOException e) {
2851       jjStopStringLiteralDfa_5(3, active0);
2852       return 4;
2853    }
2854    switch(curChar)
2855    {
2856       case 69:
2857       case 101:
2858          return jjMoveStringLiteralDfa5_5(active0, 0x8000000000000L);
2859       case 73:
2860       case 105:
2861          return jjMoveStringLiteralDfa5_5(active0, 0x4000000000000L);
2862       default :
2863          break;
2864    }
2865    return jjStartNfa_5(3, active0);
2866 }
2867 private final int jjMoveStringLiteralDfa5_5(long old0, long active0)
2868 {
2869    if (((active0 &= old0)) == 0L)
2870       return jjStartNfa_5(3, old0); 
2871    try { curChar = input_stream.readChar(); }
2872    catch(java.io.IOException e) {
2873       jjStopStringLiteralDfa_5(4, active0);
2874       return 5;
2875    }
2876    switch(curChar)
2877    {
2878       case 67:
2879       case 99:
2880          if ((active0 & 0x4000000000000L) != 0L)
2881             return jjStopAtPos(5, 50);
2882          break;
2883       case 77:
2884       case 109:
2885          if ((active0 & 0x8000000000000L) != 0L)
2886             return jjStopAtPos(5, 51);
2887          break;
2888       default :
2889          break;
2890    }
2891    return jjStartNfa_5(4, active0);
2892 }
2893 private final int jjMoveNfa_5(int startState, int curPos)
2894 {
2895    int[] nextStates;
2896    int startsAt = 0;
2897    jjnewStateCnt = 7;
2898    int i = 1;
2899    jjstateSet[0] = startState;
2900    int j, kind = 0x7fffffff;
2901    for (;;)
2902    {
2903       if (++jjround == 0x7fffffff)
2904          ReInitRounds();
2905       if (curChar < 64)
2906       {
2907          long l = 1L << curChar;
2908          MatchLoop: do
2909          {
2910             switch(jjstateSet[--i])
2911             {
2912                case 1:
2913                   if ((0x100002600L & l) != 0L)
2914                   {
2915                      if (kind > 48)
2916                         kind = 48;
2917                      jjCheckNAdd(0);
2918                   }
2919                   else if (curChar == 34)
2920                      jjCheckNAddTwoStates(5, 6);
2921                   else if (curChar == 39)
2922                      jjCheckNAddTwoStates(2, 3);
2923                   break;
2924                case 0:
2925                   if ((0x100002600L & l) == 0L)
2926                      break;
2927                   if (kind > 48)
2928                      kind = 48;
2929                   jjCheckNAdd(0);
2930                   break;
2931                case 2:
2932                   if ((0xffffff7fffffffffL & l) != 0L)
2933                      jjCheckNAddTwoStates(2, 3);
2934                   break;
2935                case 3:
2936                   if (curChar == 39 && kind > 53)
2937                      kind = 53;
2938                   break;
2939                case 4:
2940                   if (curChar == 34)
2941                      jjCheckNAddTwoStates(5, 6);
2942                   break;
2943                case 5:
2944                   if ((0xfffffffbffffffffL & l) != 0L)
2945                      jjCheckNAddTwoStates(5, 6);
2946                   break;
2947                case 6:
2948                   if (curChar == 34 && kind > 53)
2949                      kind = 53;
2950                   break;
2951                default : break;
2952             }
2953          } while(i != startsAt);
2954       }
2955       else if (curChar < 128)
2956       {
2957          long l = 1L << (curChar & 077);
2958          MatchLoop: do
2959          {
2960             switch(jjstateSet[--i])
2961             {
2962                case 2:
2963                   jjAddStates(42, 43);
2964                   break;
2965                case 5:
2966                   jjAddStates(44, 45);
2967                   break;
2968                default : break;
2969             }
2970          } while(i != startsAt);
2971       }
2972       else
2973       {
2974          int i2 = (curChar & 0xff) >> 6;
2975          long l2 = 1L << (curChar & 077);
2976          MatchLoop: do
2977          {
2978             switch(jjstateSet[--i])
2979             {
2980                case 2:
2981                   if ((jjbitVec0[i2] & l2) != 0L)
2982                      jjAddStates(42, 43);
2983                   break;
2984                case 5:
2985                   if ((jjbitVec0[i2] & l2) != 0L)
2986                      jjAddStates(44, 45);
2987                   break;
2988                default : break;
2989             }
2990          } while(i != startsAt);
2991       }
2992       if (kind != 0x7fffffff)
2993       {
2994          jjmatchedKind = kind;
2995          jjmatchedPos = curPos;
2996          kind = 0x7fffffff;
2997       }
2998       ++curPos;
2999       if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
3000          return curPos;
3001       try { curChar = input_stream.readChar(); }
3002       catch(java.io.IOException e) { return curPos; }
3003    }
3004 }
3005 private final int jjStopStringLiteralDfa_10(int pos, long active0)
3006 {
3007    switch (pos)
3008    {
3009       case 0:
3010          if ((active0 & 0x10000000000L) != 0L)
3011             return 2;
3012          return -1;
3013       default :
3014          return -1;
3015    }
3016 }
3017 private final int jjStartNfa_10(int pos, long active0)
3018 {
3019    return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1);
3020 }
3021 private final int jjStartNfaWithStates_10(int pos, int kind, int state)
3022 {
3023    jjmatchedKind = kind;
3024    jjmatchedPos = pos;
3025    try { curChar = input_stream.readChar(); }
3026    catch(java.io.IOException e) { return pos + 1; }
3027    return jjMoveNfa_10(state, pos + 1);
3028 }
3029 private final int jjMoveStringLiteralDfa0_10()
3030 {
3031    switch(curChar)
3032    {
3033       case 37:
3034          return jjMoveStringLiteralDfa1_10(0x10000000000L);
3035       default :
3036          return jjMoveNfa_10(3, 0);
3037    }
3038 }
3039 private final int jjMoveStringLiteralDfa1_10(long active0)
3040 {
3041    try { curChar = input_stream.readChar(); }
3042    catch(java.io.IOException e) {
3043       jjStopStringLiteralDfa_10(0, active0);
3044       return 1;
3045    }
3046    switch(curChar)
3047    {
3048       case 62:
3049          if ((active0 & 0x10000000000L) != 0L)
3050             return jjStopAtPos(1, 40);
3051          break;
3052       default :
3053          break;
3054    }
3055    return jjStartNfa_10(0, active0);
3056 }
3057 private final int jjMoveNfa_10(int startState, int curPos)
3058 {
3059    int[] nextStates;
3060    int startsAt = 0;
3061    jjnewStateCnt = 3;
3062    int i = 1;
3063    jjstateSet[0] = startState;
3064    int j, kind = 0x7fffffff;
3065    for (;;)
3066    {
3067       if (++jjround == 0x7fffffff)
3068          ReInitRounds();
3069       if (curChar < 64)
3070       {
3071          long l = 1L << curChar;
3072          MatchLoop: do
3073          {
3074             switch(jjstateSet[--i])
3075             {
3076                case 3:
3077                   if ((0xffffffdfffffffffL & l) != 0L)
3078                   {
3079                      if (kind > 41)
3080                         kind = 41;
3081                      jjCheckNAddTwoStates(0, 1);
3082                   }
3083                   else if (curChar == 37)
3084                      jjstateSet[jjnewStateCnt++] = 2;
3085                   break;
3086                case 0:
3087                   if ((0xffffffdfffffffffL & l) == 0L)
3088                      break;
3089                   if (kind > 41)
3090                      kind = 41;
3091                   jjCheckNAddTwoStates(0, 1);
3092                   break;
3093                case 1:
3094                   if (curChar == 37)
3095                      jjstateSet[jjnewStateCnt++] = 2;
3096                   break;
3097                case 2:
3098                   if ((0xbfffffffffffffffL & l) == 0L)
3099                      break;
3100                   if (kind > 41)
3101                      kind = 41;
3102                   jjCheckNAddTwoStates(0, 1);
3103                   break;
3104                default : break;
3105             }
3106          } while(i != startsAt);
3107       }
3108       else if (curChar < 128)
3109       {
3110          long l = 1L << (curChar & 077);
3111          MatchLoop: do
3112          {
3113             switch(jjstateSet[--i])
3114             {
3115                case 3:
3116                case 0:
3117                case 2:
3118                   if (kind > 41)
3119                      kind = 41;
3120                   jjCheckNAddTwoStates(0, 1);
3121                   break;
3122                default : break;
3123             }
3124          } while(i != startsAt);
3125       }
3126       else
3127       {
3128          int i2 = (curChar & 0xff) >> 6;
3129          long l2 = 1L << (curChar & 077);
3130          MatchLoop: do
3131          {
3132             switch(jjstateSet[--i])
3133             {
3134                case 3:
3135                case 0:
3136                case 2:
3137                   if ((jjbitVec0[i2] & l2) == 0L)
3138                      break;
3139                   if (kind > 41)
3140                      kind = 41;
3141                   jjCheckNAddTwoStates(0, 1);
3142                   break;
3143                default : break;
3144             }
3145          } while(i != startsAt);
3146       }
3147       if (kind != 0x7fffffff)
3148       {
3149          jjmatchedKind = kind;
3150          jjmatchedPos = curPos;
3151          kind = 0x7fffffff;
3152       }
3153       ++curPos;
3154       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
3155          return curPos;
3156       try { curChar = input_stream.readChar(); }
3157       catch(java.io.IOException e) { return curPos; }
3158    }
3159 }
3160 private final int jjStopStringLiteralDfa_14(int pos, long active0)
3161 {
3162    switch (pos)
3163    {
3164       default :
3165          return -1;
3166    }
3167 }
3168 private final int jjStartNfa_14(int pos, long active0)
3169 {
3170    return jjMoveNfa_14(jjStopStringLiteralDfa_14(pos, active0), pos + 1);
3171 }
3172 private final int jjStartNfaWithStates_14(int pos, int kind, int state)
3173 {
3174    jjmatchedKind = kind;
3175    jjmatchedPos = pos;
3176    try { curChar = input_stream.readChar(); }
3177    catch(java.io.IOException e) { return pos + 1; }
3178    return jjMoveNfa_14(state, pos + 1);
3179 }
3180 private final int jjMoveStringLiteralDfa0_14()
3181 {
3182    switch(curChar)
3183    {
3184       case 37:
3185          return jjMoveStringLiteralDfa1_14(0x8000000000L);
3186       case 61:
3187          return jjStopAtPos(0, 37);
3188       default :
3189          return jjMoveNfa_14(1, 0);
3190    }
3191 }
3192 private final int jjMoveStringLiteralDfa1_14(long active0)
3193 {
3194    try { curChar = input_stream.readChar(); }
3195    catch(java.io.IOException e) {
3196       jjStopStringLiteralDfa_14(0, active0);
3197       return 1;
3198    }
3199    switch(curChar)
3200    {
3201       case 62:
3202          if ((active0 & 0x8000000000L) != 0L)
3203             return jjStopAtPos(1, 39);
3204          break;
3205       default :
3206          break;
3207    }
3208    return jjStartNfa_14(0, active0);
3209 }
3210 private final int jjMoveNfa_14(int startState, int curPos)
3211 {
3212    int[] nextStates;
3213    int startsAt = 0;
3214    jjnewStateCnt = 9;
3215    int i = 1;
3216    jjstateSet[0] = startState;
3217    int j, kind = 0x7fffffff;
3218    for (;;)
3219    {
3220       if (++jjround == 0x7fffffff)
3221          ReInitRounds();
3222       if (curChar < 64)
3223       {
3224          long l = 1L << curChar;
3225          MatchLoop: do
3226          {
3227             switch(jjstateSet[--i])
3228             {
3229                case 1:
3230                   if ((0x100002600L & l) != 0L)
3231                   {
3232                      if (kind > 20)
3233                         kind = 20;
3234                      jjCheckNAdd(0);
3235                   }
3236                   else if (curChar == 34)
3237                      jjCheckNAddTwoStates(7, 8);
3238                   else if (curChar == 39)
3239                      jjCheckNAddTwoStates(4, 5);
3240                   else if (curChar == 36)
3241                   {
3242                      if (kind > 36)
3243                         kind = 36;
3244                      jjCheckNAdd(2);
3245                   }
3246                   break;
3247                case 0:
3248                   if ((0x100002600L & l) == 0L)
3249                      break;
3250                   if (kind > 20)
3251                      kind = 20;
3252                   jjCheckNAdd(0);
3253                   break;
3254                case 2:
3255                   if ((0x7ff601000000000L & l) == 0L)
3256                      break;
3257                   if (kind > 36)
3258                      kind = 36;
3259                   jjCheckNAdd(2);
3260                   break;
3261                case 3:
3262                   if (curChar == 39)
3263                      jjCheckNAddTwoStates(4, 5);
3264                   break;
3265                case 4:
3266                   if ((0xffffff7fffffffffL & l) != 0L)
3267                      jjCheckNAddTwoStates(4, 5);
3268                   break;
3269                case 5:
3270                   if (curChar == 39 && kind > 38)
3271                      kind = 38;
3272                   break;
3273                case 6:
3274                   if (curChar == 34)
3275                      jjCheckNAddTwoStates(7, 8);
3276                   break;
3277                case 7:
3278                   if ((0xfffffffbffffffffL & l) != 0L)
3279                      jjCheckNAddTwoStates(7, 8);
3280                   break;
3281                case 8:
3282                   if (curChar == 34 && kind > 38)
3283                      kind = 38;
3284                   break;
3285                default : break;
3286             }
3287          } while(i != startsAt);
3288       }
3289       else if (curChar < 128)
3290       {
3291          long l = 1L << (curChar & 077);
3292          MatchLoop: do
3293          {
3294             switch(jjstateSet[--i])
3295             {
3296                case 1:
3297                case 2:
3298                   if ((0x7fffffe87fffffeL & l) == 0L)
3299                      break;
3300                   if (kind > 36)
3301                      kind = 36;
3302                   jjCheckNAdd(2);
3303                   break;
3304                case 4:
3305                   jjAddStates(38, 39);
3306                   break;
3307                case 7:
3308                   jjAddStates(40, 41);
3309                   break;
3310                default : break;
3311             }
3312          } while(i != startsAt);
3313       }
3314       else
3315       {
3316          int i2 = (curChar & 0xff) >> 6;
3317          long l2 = 1L << (curChar & 077);
3318          MatchLoop: do
3319          {
3320             switch(jjstateSet[--i])
3321             {
3322                case 1:
3323                case 2:
3324                   if ((jjbitVec1[i2] & l2) == 0L)
3325                      break;
3326                   if (kind > 36)
3327                      kind = 36;
3328                   jjCheckNAdd(2);
3329                   break;
3330                case 4:
3331                   if ((jjbitVec0[i2] & l2) != 0L)
3332                      jjAddStates(38, 39);
3333                   break;
3334                case 7:
3335                   if ((jjbitVec0[i2] & l2) != 0L)
3336                      jjAddStates(40, 41);
3337                   break;
3338                default : break;
3339             }
3340          } while(i != startsAt);
3341       }
3342       if (kind != 0x7fffffff)
3343       {
3344          jjmatchedKind = kind;
3345          jjmatchedPos = curPos;
3346          kind = 0x7fffffff;
3347       }
3348       ++curPos;
3349       if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
3350          return curPos;
3351       try { curChar = input_stream.readChar(); }
3352       catch(java.io.IOException e) { return curPos; }
3353    }
3354 }
3355 static final int[] jjnextStates = {
3356    1, 4, 28, 29, 31, 1, 2, 5, 8, 11, 12, 15, 18, 21, 22, 25, 
3357    33, 34, 3, 4, 6, 7, 13, 14, 16, 17, 0, 1, 2, 3, 7, 11, 
3358    12, 14, 2, 3, 6, 9, 4, 5, 7, 8, 2, 3, 5, 6, 
3359 };
3360 public static final String[] jjstrLiteralImages = {
3361 "", null, null, null, null, null, null, null, null, null, null, null, null, 
3362 null, null, null, null, null, null, null, null, null, "\74", "\74\57", 
3363 "\74\41\55\55", "\74\77", null, null, "\74\45\55\55", "\74\45\41", "\74\45\75", "\74\45", 
3364 "\74\45\100", null, null, null, null, "\75", null, "\45\76", "\45\76", null, "\45\76", null, 
3365 "\45\76", null, "\55\55\45\76", null, null, null, null, null, "\76", null, null, 
3366 "\135\135\76", null, null, null, "\76", null, "\57\76", "\75", null, "\47", "\42", null, null, 
3367 null, "\47", null, null, "\42", null, null, null, null, };
3368 public static final String[] lexStateNames = {
3369    "CommentState", 
3370    "AttrValueBetweenDoubleQuotesState", 
3371    "AttrValueBetweenSingleQuotesState", 
3372    "StartTagState", 
3373    "CDataState", 
3374    "DocTypeExternalIdState", 
3375    "DocTypeState", 
3376    "JspCommentState", 
3377    "JspDeclarationState", 
3378    "JspExpressionState", 
3379    "JspScriptletState", 
3380    "InTagState", 
3381    "AfterTagState", 
3382    "AttrValueState", 
3383    "JspDirectiveAttributesState", 
3384    "JspDirectiveState", 
3385    "DEFAULT", 
3386 };
3387 public static final int[] jjnewLexState = {
3388    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 
3389    3, 6, 4, 7, 8, 9, 10, 15, -1, -1, 14, -1, -1, -1, 12, 12, -1, 12, -1, 12, -1, 12, -1, -1, 5, 
3390    -1, -1, 12, -1, -1, 12, 11, 16, -1, 12, 12, 12, 13, -1, 2, 1, -1, -1, -1, 11, -1, 11, 11, -1, 11, 
3391    12, -1, 
3392 };
3393 static final long[] jjtoToken = {
3394    0xffffffffffc00001L, 0x1fffL, 
3395 };
3396 static final long[] jjtoSkip = {
3397    0x300000L, 0x0L, 
3398 };
3399 static final long[] jjtoSpecial = {
3400    0x200000L, 0x0L, 
3401 };
3402 protected CharStream input_stream;
3403 private final int[] jjrounds = new int[37];
3404 private final int[] jjstateSet = new int[74];
3405 protected char curChar;
3406 public JspParserTokenManager(CharStream stream){
3407    input_stream = stream;
3408 }
3409 public JspParserTokenManager(CharStream stream, int lexState){
3410    this(stream);
3411    SwitchTo(lexState);
3412 }
3413 public void ReInit(CharStream stream)
3414 {
3415    jjmatchedPos = jjnewStateCnt = 0;
3416    curLexState = defaultLexState;
3417    input_stream = stream;
3418    ReInitRounds();
3419 }
3420 private final void ReInitRounds()
3421 {
3422    int i;
3423    jjround = 0x80000001;
3424    for (i = 37; i-- > 0;)
3425       jjrounds[i] = 0x80000000;
3426 }
3427 public void ReInit(CharStream stream, int lexState)
3428 {
3429    ReInit(stream);
3430    SwitchTo(lexState);
3431 }
3432 public void SwitchTo(int lexState)
3433 {
3434    if (lexState >= 17 || lexState < 0)
3435       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3436    else
3437       curLexState = lexState;
3438 }
3439 
3440 protected Token jjFillToken()
3441 {
3442    Token t = Token.newToken(jjmatchedKind);
3443    t.kind = jjmatchedKind;
3444    String im = jjstrLiteralImages[jjmatchedKind];
3445    t.image = (im == null) ? input_stream.GetImage() : im;
3446    t.beginLine = input_stream.getBeginLine();
3447    t.beginColumn = input_stream.getBeginColumn();
3448    t.endLine = input_stream.getEndLine();
3449    t.endColumn = input_stream.getEndColumn();
3450    return t;
3451 }
3452 
3453 int curLexState = 16;
3454 int defaultLexState = 16;
3455 int jjnewStateCnt;
3456 int jjround;
3457 int jjmatchedPos;
3458 int jjmatchedKind;
3459 
3460 public Token getNextToken() 
3461 {
3462   int kind;
3463   Token specialToken = null;
3464   Token matchedToken;
3465   int curPos = 0;
3466 
3467   EOFLoop :
3468   for (;;)
3469   {   
3470    try   
3471    {     
3472       curChar = input_stream.BeginToken();
3473    }     
3474    catch(java.io.IOException e)
3475    {        
3476       jjmatchedKind = 0;
3477       matchedToken = jjFillToken();
3478       matchedToken.specialToken = specialToken;
3479       return matchedToken;
3480    }
3481 
3482    switch(curLexState)
3483    {
3484      case 0:
3485        jjmatchedKind = 0x7fffffff;
3486        jjmatchedPos = 0;
3487        curPos = jjMoveStringLiteralDfa0_0();
3488        if (jjmatchedPos == 0 && jjmatchedKind > 76)
3489        {
3490           jjmatchedKind = 76;
3491        }
3492        break;
3493      case 1:
3494        jjmatchedKind = 0x7fffffff;
3495        jjmatchedPos = 0;
3496        curPos = jjMoveStringLiteralDfa0_1();
3497        break;
3498      case 2:
3499        jjmatchedKind = 0x7fffffff;
3500        jjmatchedPos = 0;
3501        curPos = jjMoveStringLiteralDfa0_2();
3502        break;
3503      case 3:
3504        jjmatchedKind = 0x7fffffff;
3505        jjmatchedPos = 0;
3506        curPos = jjMoveStringLiteralDfa0_3();
3507        if (jjmatchedPos == 0 && jjmatchedKind > 57)
3508        {
3509           jjmatchedKind = 57;
3510        }
3511        break;
3512      case 4:
3513        jjmatchedKind = 0x7fffffff;
3514        jjmatchedPos = 0;
3515        curPos = jjMoveStringLiteralDfa0_4();
3516        if (jjmatchedPos == 0 && jjmatchedKind > 54)
3517        {
3518           jjmatchedKind = 54;
3519        }
3520        break;
3521      case 5:
3522        jjmatchedKind = 0x7fffffff;
3523        jjmatchedPos = 0;
3524        curPos = jjMoveStringLiteralDfa0_5();
3525        break;
3526      case 6:
3527        jjmatchedKind = 0x7fffffff;
3528        jjmatchedPos = 0;
3529        curPos = jjMoveStringLiteralDfa0_6();
3530        break;
3531      case 7:
3532        jjmatchedKind = 0x7fffffff;
3533        jjmatchedPos = 0;
3534        curPos = jjMoveStringLiteralDfa0_7();
3535        break;
3536      case 8:
3537        jjmatchedKind = 0x7fffffff;
3538        jjmatchedPos = 0;
3539        curPos = jjMoveStringLiteralDfa0_8();
3540        break;
3541      case 9:
3542        jjmatchedKind = 0x7fffffff;
3543        jjmatchedPos = 0;
3544        curPos = jjMoveStringLiteralDfa0_9();
3545        break;
3546      case 10:
3547        jjmatchedKind = 0x7fffffff;
3548        jjmatchedPos = 0;
3549        curPos = jjMoveStringLiteralDfa0_10();
3550        break;
3551      case 11:
3552        jjmatchedKind = 0x7fffffff;
3553        jjmatchedPos = 0;
3554        curPos = jjMoveStringLiteralDfa0_11();
3555        if (jjmatchedPos == 0 && jjmatchedKind > 63)
3556        {
3557           jjmatchedKind = 63;
3558        }
3559        break;
3560      case 12:
3561        jjmatchedKind = 0x7fffffff;
3562        jjmatchedPos = 0;
3563        curPos = jjMoveStringLiteralDfa0_12();
3564        break;
3565      case 13:
3566        jjmatchedKind = 0x7fffffff;
3567        jjmatchedPos = 0;
3568        curPos = jjMoveStringLiteralDfa0_13();
3569        break;
3570      case 14:
3571        jjmatchedKind = 0x7fffffff;
3572        jjmatchedPos = 0;
3573        curPos = jjMoveStringLiteralDfa0_14();
3574        break;
3575      case 15:
3576        jjmatchedKind = 0x7fffffff;
3577        jjmatchedPos = 0;
3578        curPos = jjMoveStringLiteralDfa0_15();
3579        break;
3580      case 16:
3581        jjmatchedKind = 0x7fffffff;
3582        jjmatchedPos = 0;
3583        curPos = jjMoveStringLiteralDfa0_16();
3584        break;
3585    }
3586      if (jjmatchedKind != 0x7fffffff)
3587      {
3588         if (jjmatchedPos + 1 < curPos)
3589            input_stream.backup(curPos - jjmatchedPos - 1);
3590         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3591         {
3592            matchedToken = jjFillToken();
3593            matchedToken.specialToken = specialToken;
3594        if (jjnewLexState[jjmatchedKind] != -1)
3595          curLexState = jjnewLexState[jjmatchedKind];
3596            return matchedToken;
3597         }
3598         else
3599         {
3600            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3601            {
3602               matchedToken = jjFillToken();
3603               if (specialToken == null)
3604                  specialToken = matchedToken;
3605               else
3606               {
3607                  matchedToken.specialToken = specialToken;
3608                  specialToken = (specialToken.next = matchedToken);
3609               }
3610            }
3611          if (jjnewLexState[jjmatchedKind] != -1)
3612            curLexState = jjnewLexState[jjmatchedKind];
3613            continue EOFLoop;
3614         }
3615      }
3616      int error_line = input_stream.getEndLine();
3617      int error_column = input_stream.getEndColumn();
3618      String error_after = null;
3619      boolean EOFSeen = false;
3620      try { input_stream.readChar(); input_stream.backup(1); }
3621      catch (java.io.IOException e1) {
3622         EOFSeen = true;
3623         error_after = curPos <= 1 ? "" : input_stream.GetImage();
3624         if (curChar == '\n' || curChar == '\r') {
3625            error_line++;
3626            error_column = 0;
3627         }
3628         else
3629            error_column++;
3630      }
3631      if (!EOFSeen) {
3632         input_stream.backup(1);
3633         error_after = curPos <= 1 ? "" : input_stream.GetImage();
3634      }
3635      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3636   }
3637 }
3638 
3639 }