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