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