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