View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. VmParserTokenManager.java */
2   package net.sourceforge.pmd.lang.vm.ast;
3   import java.io.IOException;
4   import java.io.Reader;
5   import java.util.ArrayList;
6   import java.util.List;
7   import java.util.HashMap;
8   import java.util.Map;
9   import net.sourceforge.pmd.lang.ast.CharStream;
10  import net.sourceforge.pmd.lang.vm.directive.Directive;
11  import net.sourceforge.pmd.lang.vm.util.VelocityCharStream;
12  import net.sourceforge.pmd.lang.vm.util.DirectiveMapper;
13  
14  /** Token Manager. */
15  public class VmParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements VmParserConstants
16  {
17      private int fileDepth = 0;
18  
19      private int lparen = 0;
20      private int rparen = 0;
21  
22      List stateStack = new ArrayList(50);
23  
24      public boolean debugPrint = false;
25  
26      private boolean inReference;
27      public boolean inDirective;
28      private boolean inComment;
29      public  boolean inSet;
30  
31      /**
32       *  pushes the current state onto the 'state stack',
33       *  and maintains the parens counts
34       *  public because we need it in PD & VM handling
35       *
36       *  @return boolean : success.  It can fail if the state machine
37       *     gets messed up (do don't mess it up :)
38       */
39      public boolean stateStackPop()
40      {
41          ParserState s;
42          try
43          {
44              s = (ParserState) stateStack.remove(stateStack.size() - 1); // stack.pop
45          }
46          catch(IndexOutOfBoundsException e)
47          {
48              // empty stack
49              lparen=0;
50              SwitchTo(DEFAULT);
51              return false;
52          }
53  
54          if( debugPrint )
55              System.out.println(
56                  " stack pop (" + stateStack.size() + ") : lparen=" +
57                      s.lparen +
58                          " newstate=" + s.lexstate );
59  
60          lparen = s.lparen;
61          rparen = s.rparen;
62  
63          SwitchTo(s.lexstate);
64  
65          return true;
66      }
67  
68      /**
69       *  pops a state off the stack, and restores paren counts
70       *
71       *  @return boolean : success of operation
72       */
73      public boolean stateStackPush()
74      {
75          if( debugPrint )
76              System.out.println(" (" + stateStack.size() + ") pushing cur state : " +
77                  curLexState );
78  
79          ParserState s = new ParserState();
80          s.lparen = lparen;
81          s.rparen = rparen;
82          s.lexstate = curLexState;
83  
84          lparen = 0;
85          stateStack.add(s); // stack.push
86  
87          return true;
88      }
89  
90      /**
91       *  Clears all state variables, resets to
92       *  start values, clears stateStack.  Call
93       *  before parsing.
94       */
95      public void clearStateVars()
96      {
97          stateStack.clear();
98  
99          lparen = 0;
100         rparen = 0;
101         inReference = false;
102         inDirective = false;
103         inComment = false;
104         inSet = false;
105 
106         return;
107     }
108 
109     /**
110      * Holds the state of the parsing process.
111      */
112     private static class ParserState
113     {
114         int lparen;
115         int rparen;
116         int lexstate;
117     }
118 
119     /**
120      *  handles the dropdown logic when encountering a RPAREN
121      */
122     private void RPARENHandler()
123     {
124         /*
125          *  Ultimately, we want to drop down to the state below
126          *  the one that has an open (if we hit bottom (DEFAULT),
127          *  that's fine. It's just text schmoo.
128          */
129 
130         boolean closed = false;
131 
132         if (inComment)
133             closed = true;
134 
135         while( !closed )
136         {
137             /*
138              * look at current state.  If we haven't seen a lparen
139              * in this state then we drop a state, because this
140              * lparen clearly closes our state
141              */
142 
143             if( lparen > 0)
144             {
145                 /*
146                  *  if rparen + 1 == lparen, then this state is closed.
147                  * Otherwise, increment and keep parsing
148                  */
149 
150                  if( lparen == rparen + 1)
151                  {
152                        stateStackPop();
153                  }
154                 else
155                 {
156                     rparen++;
157                 }
158 
159                  closed = true;
160             }
161             else
162             {
163                 /*
164                  * now, drop a state
165                  */
166 
167                 if(!stateStackPop())
168                     break;
169             }
170         }
171     }
172 
173   /** Debug output. */
174   public  java.io.PrintStream debugStream = System.out;
175   /** Set debug output. */
176   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
177 private final int jjStopStringLiteralDfa_3(int pos, long active0)
178 {
179    switch (pos)
180    {
181       case 0:
182          if ((active0 & 0x2000000000L) != 0L)
183             return 105;
184          if ((active0 & 0x200L) != 0L)
185             return 69;
186          if ((active0 & 0xc00000080L) != 0L)
187          {
188             jjmatchedKind = 63;
189             return 67;
190          }
191          if ((active0 & 0x40L) != 0L)
192             return 62;
193          if ((active0 & 0x8000000000000L) != 0L)
194             return 54;
195          if ((active0 & 0x740000L) != 0L)
196             return 7;
197          return -1;
198       case 1:
199          if ((active0 & 0x80L) != 0L)
200             return 67;
201          if ((active0 & 0x100000L) != 0L)
202             return 5;
203          if ((active0 & 0xc00000000L) != 0L)
204          {
205             jjmatchedKind = 63;
206             jjmatchedPos = 1;
207             return 67;
208          }
209          return -1;
210       case 2:
211          if ((active0 & 0xc00000000L) != 0L)
212          {
213             jjmatchedKind = 63;
214             jjmatchedPos = 2;
215             return 67;
216          }
217          return -1;
218       case 3:
219          if ((active0 & 0x400000000L) != 0L)
220             return 67;
221          if ((active0 & 0x800000000L) != 0L)
222          {
223             jjmatchedKind = 63;
224             jjmatchedPos = 3;
225             return 67;
226          }
227          return -1;
228       default :
229          return -1;
230    }
231 }
232 private final int jjStartNfa_3(int pos, long active0)
233 {
234    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
235 }
236 private int jjStopAtPos(int pos, int kind)
237 {
238    jjmatchedKind = kind;
239    jjmatchedPos = pos;
240    return pos + 1;
241 }
242 private int jjMoveStringLiteralDfa0_3()
243 {
244    switch(curChar)
245    {
246       case 35:
247          jjmatchedKind = 21;
248          return jjMoveStringLiteralDfa1_3(0x540000L);
249       case 37:
250          return jjStopAtPos(0, 41);
251       case 40:
252          return jjStopAtPos(0, 11);
253       case 42:
254          return jjStopAtPos(0, 39);
255       case 43:
256          return jjStopAtPos(0, 38);
257       case 44:
258          return jjStopAtPos(0, 5);
259       case 45:
260          return jjStartNfaWithStates_3(0, 37, 105);
261       case 46:
262          return jjMoveStringLiteralDfa1_3(0x40L);
263       case 47:
264          return jjStopAtPos(0, 40);
265       case 58:
266          return jjStopAtPos(0, 8);
267       case 61:
268          return jjStartNfaWithStates_3(0, 51, 54);
269       case 91:
270          return jjStopAtPos(0, 3);
271       case 93:
272          return jjStopAtPos(0, 4);
273       case 70:
274       case 102:
275          return jjMoveStringLiteralDfa1_3(0x800000000L);
276       case 73:
277       case 105:
278          return jjMoveStringLiteralDfa1_3(0x80L);
279       case 84:
280       case 116:
281          return jjMoveStringLiteralDfa1_3(0x400000000L);
282       case 123:
283          return jjStartNfaWithStates_3(0, 9, 69);
284       case 125:
285          return jjStopAtPos(0, 10);
286       default :
287          return jjMoveNfa_3(0, 0);
288    }
289 }
290 private int jjMoveStringLiteralDfa1_3(long active0)
291 {
292    try { curChar = input_stream.readChar(); }
293    catch(java.io.IOException e) {
294       jjStopStringLiteralDfa_3(0, active0);
295       return 1;
296    }
297    switch(curChar)
298    {
299       case 35:
300          if ((active0 & 0x400000L) != 0L)
301             return jjStopAtPos(1, 22);
302          break;
303       case 42:
304          if ((active0 & 0x100000L) != 0L)
305             return jjStartNfaWithStates_3(1, 20, 5);
306          break;
307       case 46:
308          if ((active0 & 0x40L) != 0L)
309             return jjStopAtPos(1, 6);
310          break;
311       case 91:
312          return jjMoveStringLiteralDfa2_3(active0, 0x40000L);
313       case 65:
314       case 97:
315          return jjMoveStringLiteralDfa2_3(active0, 0x800000000L);
316       case 78:
317       case 110:
318          if ((active0 & 0x80L) != 0L)
319             return jjStartNfaWithStates_3(1, 7, 67);
320          break;
321       case 82:
322       case 114:
323          return jjMoveStringLiteralDfa2_3(active0, 0x400000000L);
324       default :
325          break;
326    }
327    return jjStartNfa_3(0, active0);
328 }
329 private int jjMoveStringLiteralDfa2_3(long old0, long active0)
330 {
331    if (((active0 &= old0)) == 0L)
332       return jjStartNfa_3(0, old0);
333    try { curChar = input_stream.readChar(); }
334    catch(java.io.IOException e) {
335       jjStopStringLiteralDfa_3(1, active0);
336       return 2;
337    }
338    switch(curChar)
339    {
340       case 91:
341          if ((active0 & 0x40000L) != 0L)
342             return jjStopAtPos(2, 18);
343          break;
344       case 76:
345       case 108:
346          return jjMoveStringLiteralDfa3_3(active0, 0x800000000L);
347       case 85:
348       case 117:
349          return jjMoveStringLiteralDfa3_3(active0, 0x400000000L);
350       default :
351          break;
352    }
353    return jjStartNfa_3(1, active0);
354 }
355 private int jjMoveStringLiteralDfa3_3(long old0, long active0)
356 {
357    if (((active0 &= old0)) == 0L)
358       return jjStartNfa_3(1, old0);
359    try { curChar = input_stream.readChar(); }
360    catch(java.io.IOException e) {
361       jjStopStringLiteralDfa_3(2, active0);
362       return 3;
363    }
364    switch(curChar)
365    {
366       case 69:
367       case 101:
368          if ((active0 & 0x400000000L) != 0L)
369             return jjStartNfaWithStates_3(3, 34, 67);
370          break;
371       case 83:
372       case 115:
373          return jjMoveStringLiteralDfa4_3(active0, 0x800000000L);
374       default :
375          break;
376    }
377    return jjStartNfa_3(2, active0);
378 }
379 private int jjMoveStringLiteralDfa4_3(long old0, long active0)
380 {
381    if (((active0 &= old0)) == 0L)
382       return jjStartNfa_3(2, old0);
383    try { curChar = input_stream.readChar(); }
384    catch(java.io.IOException e) {
385       jjStopStringLiteralDfa_3(3, active0);
386       return 4;
387    }
388    switch(curChar)
389    {
390       case 69:
391       case 101:
392          if ((active0 & 0x800000000L) != 0L)
393             return jjStartNfaWithStates_3(4, 35, 67);
394          break;
395       default :
396          break;
397    }
398    return jjStartNfa_3(3, active0);
399 }
400 private int jjStartNfaWithStates_3(int pos, int kind, int state)
401 {
402    jjmatchedKind = kind;
403    jjmatchedPos = pos;
404    try { curChar = input_stream.readChar(); }
405    catch(java.io.IOException e) { return pos + 1; }
406    return jjMoveNfa_3(state, pos + 1);
407 }
408 static final long[] jjbitVec0 = {
409    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
410 };
411 static final long[] jjbitVec2 = {
412    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
413 };
414 private int jjMoveNfa_3(int startState, int curPos)
415 {
416    int startsAt = 0;
417    jjnewStateCnt = 105;
418    int i = 1;
419    jjstateSet[0] = startState;
420    int kind = 0x7fffffff;
421    for (;;)
422    {
423       if (++jjround == 0x7fffffff)
424          ReInitRounds();
425       if (curChar < 64)
426       {
427          long l = 1L << curChar;
428          do
429          {
430             switch(jjstateSet[--i])
431             {
432                case 105:
433                   if ((0x3ff000000000000L & l) != 0L)
434                      jjCheckNAddTwoStates(100, 101);
435                   else if (curChar == 46)
436                      jjCheckNAdd(62);
437                   if ((0x3ff000000000000L & l) != 0L)
438                      jjCheckNAddTwoStates(94, 95);
439                   if ((0x3ff000000000000L & l) != 0L)
440                   {
441                      if (kind > 58)
442                         kind = 58;
443                      jjCheckNAddTwoStates(91, 93);
444                   }
445                   break;
446                case 0:
447                   if ((0x3ff000000000000L & l) != 0L)
448                   {
449                      if (kind > 58)
450                         kind = 58;
451                      jjCheckNAddStates(0, 5);
452                   }
453                   else if ((0x100002600L & l) != 0L)
454                   {
455                      if (kind > 32)
456                         kind = 32;
457                      jjCheckNAdd(9);
458                   }
459                   else if (curChar == 45)
460                      jjCheckNAddStates(6, 9);
461                   else if (curChar == 36)
462                   {
463                      if (kind > 16)
464                         kind = 16;
465                      jjCheckNAddTwoStates(77, 78);
466                   }
467                   else if (curChar == 46)
468                      jjCheckNAdd(62);
469                   else if (curChar == 33)
470                   {
471                      if (kind > 50)
472                         kind = 50;
473                   }
474                   else if (curChar == 61)
475                      jjstateSet[jjnewStateCnt++] = 54;
476                   else if (curChar == 62)
477                      jjstateSet[jjnewStateCnt++] = 52;
478                   else if (curChar == 60)
479                      jjstateSet[jjnewStateCnt++] = 49;
480                   else if (curChar == 38)
481                      jjstateSet[jjnewStateCnt++] = 39;
482                   else if (curChar == 39)
483                      jjCheckNAddStates(10, 13);
484                   else if (curChar == 34)
485                      jjCheckNAddStates(14, 17);
486                   else if (curChar == 35)
487                      jjstateSet[jjnewStateCnt++] = 7;
488                   else if (curChar == 41)
489                   {
490                      if (kind > 12)
491                         kind = 12;
492                      jjCheckNAddStates(18, 20);
493                   }
494                   if ((0x2400L & l) != 0L)
495                   {
496                      if (kind > 36)
497                         kind = 36;
498                   }
499                   else if (curChar == 33)
500                      jjstateSet[jjnewStateCnt++] = 58;
501                   else if (curChar == 62)
502                   {
503                      if (kind > 46)
504                         kind = 46;
505                   }
506                   else if (curChar == 60)
507                   {
508                      if (kind > 44)
509                         kind = 44;
510                   }
511                   if (curChar == 13)
512                      jjstateSet[jjnewStateCnt++] = 37;
513                   break;
514                case 1:
515                   if ((0x100000200L & l) != 0L)
516                      jjCheckNAddStates(18, 20);
517                   break;
518                case 2:
519                   if ((0x2400L & l) != 0L && kind > 12)
520                      kind = 12;
521                   break;
522                case 3:
523                   if (curChar == 10 && kind > 12)
524                      kind = 12;
525                   break;
526                case 4:
527                   if (curChar == 13)
528                      jjstateSet[jjnewStateCnt++] = 3;
529                   break;
530                case 5:
531                   if (curChar == 42)
532                      jjstateSet[jjnewStateCnt++] = 6;
533                   break;
534                case 6:
535                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
536                      kind = 19;
537                   break;
538                case 7:
539                   if (curChar == 42)
540                      jjstateSet[jjnewStateCnt++] = 5;
541                   break;
542                case 8:
543                   if (curChar == 35)
544                      jjstateSet[jjnewStateCnt++] = 7;
545                   break;
546                case 9:
547                   if ((0x100002600L & l) == 0L)
548                      break;
549                   if (kind > 32)
550                      kind = 32;
551                   jjCheckNAdd(9);
552                   break;
553                case 10:
554                case 12:
555                   if (curChar == 34)
556                      jjCheckNAddStates(14, 17);
557                   break;
558                case 11:
559                   if ((0xfffffffbffffffffL & l) != 0L)
560                      jjCheckNAddStates(14, 17);
561                   break;
562                case 13:
563                   if (curChar == 34)
564                      jjstateSet[jjnewStateCnt++] = 12;
565                   break;
566                case 14:
567                   if (curChar == 34 && kind > 33)
568                      kind = 33;
569                   break;
570                case 17:
571                   if ((0xff000000000000L & l) != 0L)
572                      jjCheckNAddStates(21, 25);
573                   break;
574                case 18:
575                   if ((0xff000000000000L & l) != 0L)
576                      jjCheckNAddStates(14, 17);
577                   break;
578                case 19:
579                   if ((0xf000000000000L & l) != 0L)
580                      jjstateSet[jjnewStateCnt++] = 20;
581                   break;
582                case 20:
583                   if ((0xff000000000000L & l) != 0L)
584                      jjCheckNAdd(18);
585                   break;
586                case 22:
587                   if ((0x3ff000000000000L & l) != 0L)
588                      jjstateSet[jjnewStateCnt++] = 23;
589                   break;
590                case 23:
591                   if ((0x3ff000000000000L & l) != 0L)
592                      jjstateSet[jjnewStateCnt++] = 24;
593                   break;
594                case 24:
595                   if ((0x3ff000000000000L & l) != 0L)
596                      jjstateSet[jjnewStateCnt++] = 25;
597                   break;
598                case 25:
599                   if ((0x3ff000000000000L & l) != 0L)
600                      jjCheckNAddStates(14, 17);
601                   break;
602                case 26:
603                   if (curChar == 32)
604                      jjAddStates(26, 27);
605                   break;
606                case 27:
607                   if (curChar == 10)
608                      jjCheckNAddStates(14, 17);
609                   break;
610                case 28:
611                case 30:
612                   if (curChar == 39)
613                      jjCheckNAddStates(10, 13);
614                   break;
615                case 29:
616                   if ((0xffffff7fffffffffL & l) != 0L)
617                      jjCheckNAddStates(10, 13);
618                   break;
619                case 31:
620                   if (curChar == 39)
621                      jjstateSet[jjnewStateCnt++] = 30;
622                   break;
623                case 33:
624                   if (curChar == 32)
625                      jjAddStates(28, 29);
626                   break;
627                case 34:
628                   if (curChar == 10)
629                      jjCheckNAddStates(10, 13);
630                   break;
631                case 35:
632                   if (curChar == 39 && kind > 33)
633                      kind = 33;
634                   break;
635                case 36:
636                   if ((0x2400L & l) != 0L && kind > 36)
637                      kind = 36;
638                   break;
639                case 37:
640                   if (curChar == 10 && kind > 36)
641                      kind = 36;
642                   break;
643                case 38:
644                   if (curChar == 13)
645                      jjstateSet[jjnewStateCnt++] = 37;
646                   break;
647                case 39:
648                   if (curChar == 38 && kind > 42)
649                      kind = 42;
650                   break;
651                case 40:
652                   if (curChar == 38)
653                      jjstateSet[jjnewStateCnt++] = 39;
654                   break;
655                case 48:
656                   if (curChar == 60 && kind > 44)
657                      kind = 44;
658                   break;
659                case 49:
660                   if (curChar == 61 && kind > 45)
661                      kind = 45;
662                   break;
663                case 50:
664                   if (curChar == 60)
665                      jjstateSet[jjnewStateCnt++] = 49;
666                   break;
667                case 51:
668                   if (curChar == 62 && kind > 46)
669                      kind = 46;
670                   break;
671                case 52:
672                   if (curChar == 61 && kind > 47)
673                      kind = 47;
674                   break;
675                case 53:
676                   if (curChar == 62)
677                      jjstateSet[jjnewStateCnt++] = 52;
678                   break;
679                case 54:
680                   if (curChar == 61 && kind > 48)
681                      kind = 48;
682                   break;
683                case 55:
684                   if (curChar == 61)
685                      jjstateSet[jjnewStateCnt++] = 54;
686                   break;
687                case 58:
688                   if (curChar == 61 && kind > 49)
689                      kind = 49;
690                   break;
691                case 59:
692                   if (curChar == 33)
693                      jjstateSet[jjnewStateCnt++] = 58;
694                   break;
695                case 60:
696                   if (curChar == 33 && kind > 50)
697                      kind = 50;
698                   break;
699                case 61:
700                   if (curChar == 46)
701                      jjCheckNAdd(62);
702                   break;
703                case 62:
704                   if ((0x3ff000000000000L & l) == 0L)
705                      break;
706                   if (kind > 59)
707                      kind = 59;
708                   jjCheckNAddTwoStates(62, 63);
709                   break;
710                case 64:
711                   if ((0x280000000000L & l) != 0L)
712                      jjCheckNAdd(65);
713                   break;
714                case 65:
715                   if ((0x3ff000000000000L & l) == 0L)
716                      break;
717                   if (kind > 59)
718                      kind = 59;
719                   jjCheckNAdd(65);
720                   break;
721                case 67:
722                   if ((0x3ff000000000000L & l) == 0L)
723                      break;
724                   if (kind > 63)
725                      kind = 63;
726                   jjstateSet[jjnewStateCnt++] = 67;
727                   break;
728                case 70:
729                   if ((0x3ff000000000000L & l) != 0L)
730                      jjAddStates(30, 31);
731                   break;
732                case 74:
733                   if (curChar == 36 && kind > 16)
734                      kind = 16;
735                   break;
736                case 76:
737                   if (curChar == 36)
738                      jjCheckNAddTwoStates(77, 78);
739                   break;
740                case 78:
741                   if (curChar == 33 && kind > 17)
742                      kind = 17;
743                   break;
744                case 79:
745                   if (curChar != 36)
746                      break;
747                   if (kind > 16)
748                      kind = 16;
749                   jjCheckNAddTwoStates(77, 78);
750                   break;
751                case 90:
752                   if (curChar == 45)
753                      jjCheckNAddStates(6, 9);
754                   break;
755                case 91:
756                   if ((0x3ff000000000000L & l) == 0L)
757                      break;
758                   if (kind > 58)
759                      kind = 58;
760                   jjCheckNAddTwoStates(91, 93);
761                   break;
762                case 92:
763                   if (curChar == 46 && kind > 58)
764                      kind = 58;
765                   break;
766                case 93:
767                   if (curChar == 46)
768                      jjstateSet[jjnewStateCnt++] = 92;
769                   break;
770                case 94:
771                   if ((0x3ff000000000000L & l) != 0L)
772                      jjCheckNAddTwoStates(94, 95);
773                   break;
774                case 95:
775                   if (curChar != 46)
776                      break;
777                   if (kind > 59)
778                      kind = 59;
779                   jjCheckNAddTwoStates(96, 97);
780                   break;
781                case 96:
782                   if ((0x3ff000000000000L & l) == 0L)
783                      break;
784                   if (kind > 59)
785                      kind = 59;
786                   jjCheckNAddTwoStates(96, 97);
787                   break;
788                case 98:
789                   if ((0x280000000000L & l) != 0L)
790                      jjCheckNAdd(99);
791                   break;
792                case 99:
793                   if ((0x3ff000000000000L & l) == 0L)
794                      break;
795                   if (kind > 59)
796                      kind = 59;
797                   jjCheckNAdd(99);
798                   break;
799                case 100:
800                   if ((0x3ff000000000000L & l) != 0L)
801                      jjCheckNAddTwoStates(100, 101);
802                   break;
803                case 102:
804                   if ((0x280000000000L & l) != 0L)
805                      jjCheckNAdd(103);
806                   break;
807                case 103:
808                   if ((0x3ff000000000000L & l) == 0L)
809                      break;
810                   if (kind > 59)
811                      kind = 59;
812                   jjCheckNAdd(103);
813                   break;
814                case 104:
815                   if ((0x3ff000000000000L & l) == 0L)
816                      break;
817                   if (kind > 58)
818                      kind = 58;
819                   jjCheckNAddStates(0, 5);
820                   break;
821                default : break;
822             }
823          } while(i != startsAt);
824       }
825       else if (curChar < 128)
826       {
827          long l = 1L << (curChar & 077);
828          do
829          {
830             switch(jjstateSet[--i])
831             {
832                case 0:
833                   if ((0x7fffffe87ffffffL & l) != 0L)
834                   {
835                      if (kind > 63)
836                         kind = 63;
837                      jjCheckNAdd(67);
838                   }
839                   else if (curChar == 92)
840                      jjCheckNAddStates(32, 35);
841                   else if (curChar == 123)
842                      jjstateSet[jjnewStateCnt++] = 69;
843                   else if (curChar == 124)
844                      jjstateSet[jjnewStateCnt++] = 44;
845                   if ((0x400000004000L & l) != 0L)
846                      jjAddStates(36, 37);
847                   else if ((0x8000000080L & l) != 0L)
848                      jjAddStates(38, 39);
849                   else if ((0x100000001000L & l) != 0L)
850                      jjAddStates(40, 41);
851                   else if ((0x2000000020L & l) != 0L)
852                      jjstateSet[jjnewStateCnt++] = 56;
853                   else if ((0x800000008000L & l) != 0L)
854                      jjstateSet[jjnewStateCnt++] = 46;
855                   else if ((0x200000002L & l) != 0L)
856                      jjstateSet[jjnewStateCnt++] = 42;
857                   break;
858                case 6:
859                   if (kind > 19)
860                      kind = 19;
861                   break;
862                case 11:
863                   jjCheckNAddStates(14, 17);
864                   break;
865                case 15:
866                   if (curChar == 92)
867                      jjAddStates(42, 47);
868                   break;
869                case 16:
870                   if ((0x14404400144044L & l) != 0L)
871                      jjCheckNAddStates(14, 17);
872                   break;
873                case 21:
874                   if ((0x20000000200000L & l) != 0L)
875                      jjstateSet[jjnewStateCnt++] = 22;
876                   break;
877                case 22:
878                   if ((0x7e0000007eL & l) != 0L)
879                      jjstateSet[jjnewStateCnt++] = 23;
880                   break;
881                case 23:
882                   if ((0x7e0000007eL & l) != 0L)
883                      jjstateSet[jjnewStateCnt++] = 24;
884                   break;
885                case 24:
886                   if ((0x7e0000007eL & l) != 0L)
887                      jjstateSet[jjnewStateCnt++] = 25;
888                   break;
889                case 25:
890                   if ((0x7e0000007eL & l) != 0L)
891                      jjCheckNAddStates(14, 17);
892                   break;
893                case 29:
894                   jjAddStates(10, 13);
895                   break;
896                case 32:
897                   if (curChar == 92)
898                      jjAddStates(28, 29);
899                   break;
900                case 41:
901                   if ((0x1000000010L & l) != 0L && kind > 42)
902                      kind = 42;
903                   break;
904                case 42:
905                   if ((0x400000004000L & l) != 0L)
906                      jjstateSet[jjnewStateCnt++] = 41;
907                   break;
908                case 43:
909                   if ((0x200000002L & l) != 0L)
910                      jjstateSet[jjnewStateCnt++] = 42;
911                   break;
912                case 44:
913                   if (curChar == 124 && kind > 43)
914                      kind = 43;
915                   break;
916                case 45:
917                   if (curChar == 124)
918                      jjstateSet[jjnewStateCnt++] = 44;
919                   break;
920                case 46:
921                   if ((0x4000000040000L & l) != 0L && kind > 43)
922                      kind = 43;
923                   break;
924                case 47:
925                   if ((0x800000008000L & l) != 0L)
926                      jjstateSet[jjnewStateCnt++] = 46;
927                   break;
928                case 56:
929                   if ((0x2000000020000L & l) != 0L && kind > 48)
930                      kind = 48;
931                   break;
932                case 57:
933                   if ((0x2000000020L & l) != 0L)
934                      jjstateSet[jjnewStateCnt++] = 56;
935                   break;
936                case 63:
937                   if ((0x2000000020L & l) != 0L)
938                      jjAddStates(48, 49);
939                   break;
940                case 66:
941                case 67:
942                   if ((0x7fffffe87ffffffL & l) == 0L)
943                      break;
944                   if (kind > 63)
945                      kind = 63;
946                   jjCheckNAdd(67);
947                   break;
948                case 68:
949                   if (curChar == 123)
950                      jjstateSet[jjnewStateCnt++] = 69;
951                   break;
952                case 69:
953                   if ((0x7fffffe87fffffeL & l) != 0L)
954                      jjCheckNAddTwoStates(70, 71);
955                   break;
956                case 70:
957                   if ((0x7fffffe87ffffffL & l) != 0L)
958                      jjCheckNAddTwoStates(70, 71);
959                   break;
960                case 71:
961                   if (curChar == 125 && kind > 64)
962                      kind = 64;
963                   break;
964                case 72:
965                   if (curChar == 92)
966                      jjCheckNAddStates(32, 35);
967                   break;
968                case 73:
969                   if (curChar == 92)
970                      jjCheckNAddTwoStates(73, 74);
971                   break;
972                case 75:
973                   if (curChar == 92)
974                      jjCheckNAddTwoStates(75, 76);
975                   break;
976                case 77:
977                   if (curChar == 92)
978                      jjAddStates(50, 51);
979                   break;
980                case 80:
981                   if ((0x100000001000L & l) != 0L)
982                      jjAddStates(40, 41);
983                   break;
984                case 81:
985                   if ((0x10000000100000L & l) != 0L && kind > 44)
986                      kind = 44;
987                   break;
988                case 82:
989                   if ((0x2000000020L & l) != 0L && kind > 45)
990                      kind = 45;
991                   break;
992                case 83:
993                   if ((0x8000000080L & l) != 0L)
994                      jjAddStates(38, 39);
995                   break;
996                case 84:
997                   if ((0x10000000100000L & l) != 0L && kind > 46)
998                      kind = 46;
999                   break;
1000                case 85:
1001                   if ((0x2000000020L & l) != 0L && kind > 47)
1002                      kind = 47;
1003                   break;
1004                case 86:
1005                   if ((0x400000004000L & l) != 0L)
1006                      jjAddStates(36, 37);
1007                   break;
1008                case 87:
1009                   if ((0x2000000020L & l) != 0L && kind > 49)
1010                      kind = 49;
1011                   break;
1012                case 88:
1013                   if ((0x10000000100000L & l) != 0L && kind > 50)
1014                      kind = 50;
1015                   break;
1016                case 89:
1017                   if ((0x800000008000L & l) != 0L)
1018                      jjstateSet[jjnewStateCnt++] = 88;
1019                   break;
1020                case 97:
1021                   if ((0x2000000020L & l) != 0L)
1022                      jjAddStates(52, 53);
1023                   break;
1024                case 101:
1025                   if ((0x2000000020L & l) != 0L)
1026                      jjAddStates(54, 55);
1027                   break;
1028                default : break;
1029             }
1030          } while(i != startsAt);
1031       }
1032       else
1033       {
1034          int hiByte = (int)(curChar >> 8);
1035          int i1 = hiByte >> 6;
1036          long l1 = 1L << (hiByte & 077);
1037          int i2 = (curChar & 0xff) >> 6;
1038          long l2 = 1L << (curChar & 077);
1039          do
1040          {
1041             switch(jjstateSet[--i])
1042             {
1043                case 6:
1044                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
1045                      kind = 19;
1046                   break;
1047                case 11:
1048                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1049                      jjAddStates(14, 17);
1050                   break;
1051                case 29:
1052                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1053                      jjAddStates(10, 13);
1054                   break;
1055                default : break;
1056             }
1057          } while(i != startsAt);
1058       }
1059       if (kind != 0x7fffffff)
1060       {
1061          jjmatchedKind = kind;
1062          jjmatchedPos = curPos;
1063          kind = 0x7fffffff;
1064       }
1065       ++curPos;
1066       if ((i = jjnewStateCnt) == (startsAt = 105 - (jjnewStateCnt = startsAt)))
1067          return curPos;
1068       try { curChar = input_stream.readChar(); }
1069       catch(java.io.IOException e) { return curPos; }
1070    }
1071 }
1072 private final int jjStopStringLiteralDfa_11(int pos, long active0)
1073 {
1074    switch (pos)
1075    {
1076       case 0:
1077          if ((active0 & 0x740000L) != 0L)
1078             return 2;
1079          return -1;
1080       case 1:
1081          if ((active0 & 0x100000L) != 0L)
1082             return 0;
1083          return -1;
1084       default :
1085          return -1;
1086    }
1087 }
1088 private final int jjStartNfa_11(int pos, long active0)
1089 {
1090    return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
1091 }
1092 private int jjMoveStringLiteralDfa0_11()
1093 {
1094    switch(curChar)
1095    {
1096       case 35:
1097          jjmatchedKind = 21;
1098          return jjMoveStringLiteralDfa1_11(0x540000L);
1099       default :
1100          return jjMoveNfa_11(3, 0);
1101    }
1102 }
1103 private int jjMoveStringLiteralDfa1_11(long active0)
1104 {
1105    try { curChar = input_stream.readChar(); }
1106    catch(java.io.IOException e) {
1107       jjStopStringLiteralDfa_11(0, active0);
1108       return 1;
1109    }
1110    switch(curChar)
1111    {
1112       case 35:
1113          if ((active0 & 0x400000L) != 0L)
1114             return jjStopAtPos(1, 22);
1115          break;
1116       case 42:
1117          if ((active0 & 0x100000L) != 0L)
1118             return jjStartNfaWithStates_11(1, 20, 0);
1119          break;
1120       case 91:
1121          return jjMoveStringLiteralDfa2_11(active0, 0x40000L);
1122       default :
1123          break;
1124    }
1125    return jjStartNfa_11(0, active0);
1126 }
1127 private int jjMoveStringLiteralDfa2_11(long old0, long active0)
1128 {
1129    if (((active0 &= old0)) == 0L)
1130       return jjStartNfa_11(0, old0);
1131    try { curChar = input_stream.readChar(); }
1132    catch(java.io.IOException e) {
1133       jjStopStringLiteralDfa_11(1, active0);
1134       return 2;
1135    }
1136    switch(curChar)
1137    {
1138       case 91:
1139          if ((active0 & 0x40000L) != 0L)
1140             return jjStopAtPos(2, 18);
1141          break;
1142       default :
1143          break;
1144    }
1145    return jjStartNfa_11(1, active0);
1146 }
1147 private int jjStartNfaWithStates_11(int pos, int kind, int state)
1148 {
1149    jjmatchedKind = kind;
1150    jjmatchedPos = pos;
1151    try { curChar = input_stream.readChar(); }
1152    catch(java.io.IOException e) { return pos + 1; }
1153    return jjMoveNfa_11(state, pos + 1);
1154 }
1155 private int jjMoveNfa_11(int startState, int curPos)
1156 {
1157    int startsAt = 0;
1158    jjnewStateCnt = 98;
1159    int i = 1;
1160    jjstateSet[0] = startState;
1161    int kind = 0x7fffffff;
1162    for (;;)
1163    {
1164       if (++jjround == 0x7fffffff)
1165          ReInitRounds();
1166       if (curChar < 64)
1167       {
1168          long l = 1L << curChar;
1169          do
1170          {
1171             switch(jjstateSet[--i])
1172             {
1173                case 3:
1174                   if ((0x3ff000000000000L & l) != 0L)
1175                   {
1176                      if (kind > 58)
1177                         kind = 58;
1178                      jjCheckNAddStates(56, 61);
1179                   }
1180                   else if (curChar == 45)
1181                      jjCheckNAddStates(62, 65);
1182                   else if (curChar == 36)
1183                   {
1184                      if (kind > 16)
1185                         kind = 16;
1186                      jjCheckNAddTwoStates(29, 30);
1187                   }
1188                   else if (curChar == 46)
1189                      jjCheckNAdd(14);
1190                   else if (curChar == 35)
1191                      jjstateSet[jjnewStateCnt++] = 2;
1192                   break;
1193                case 0:
1194                   if (curChar == 42)
1195                      jjstateSet[jjnewStateCnt++] = 1;
1196                   break;
1197                case 1:
1198                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
1199                      kind = 19;
1200                   break;
1201                case 2:
1202                   if (curChar == 42)
1203                      jjstateSet[jjnewStateCnt++] = 0;
1204                   break;
1205                case 13:
1206                   if (curChar == 46)
1207                      jjCheckNAdd(14);
1208                   break;
1209                case 14:
1210                   if ((0x3ff000000000000L & l) == 0L)
1211                      break;
1212                   if (kind > 59)
1213                      kind = 59;
1214                   jjCheckNAddTwoStates(14, 15);
1215                   break;
1216                case 16:
1217                   if ((0x280000000000L & l) != 0L)
1218                      jjCheckNAdd(17);
1219                   break;
1220                case 17:
1221                   if ((0x3ff000000000000L & l) == 0L)
1222                      break;
1223                   if (kind > 59)
1224                      kind = 59;
1225                   jjCheckNAdd(17);
1226                   break;
1227                case 19:
1228                   if ((0x3ff000000000000L & l) == 0L)
1229                      break;
1230                   if (kind > 63)
1231                      kind = 63;
1232                   jjstateSet[jjnewStateCnt++] = 19;
1233                   break;
1234                case 22:
1235                   if ((0x3ff000000000000L & l) != 0L)
1236                      jjAddStates(66, 67);
1237                   break;
1238                case 26:
1239                   if (curChar == 36 && kind > 16)
1240                      kind = 16;
1241                   break;
1242                case 28:
1243                   if (curChar == 36)
1244                      jjCheckNAddTwoStates(29, 30);
1245                   break;
1246                case 30:
1247                   if (curChar == 33 && kind > 17)
1248                      kind = 17;
1249                   break;
1250                case 31:
1251                   if (curChar != 36)
1252                      break;
1253                   if (kind > 16)
1254                      kind = 16;
1255                   jjCheckNAddTwoStates(29, 30);
1256                   break;
1257                case 34:
1258                   if ((0x100000200L & l) != 0L)
1259                      jjCheckNAddStates(68, 70);
1260                   break;
1261                case 35:
1262                   if ((0x2400L & l) != 0L && kind > 52)
1263                      kind = 52;
1264                   break;
1265                case 36:
1266                   if (curChar == 10 && kind > 52)
1267                      kind = 52;
1268                   break;
1269                case 37:
1270                case 54:
1271                   if (curChar == 13)
1272                      jjCheckNAdd(36);
1273                   break;
1274                case 45:
1275                   if ((0x100000200L & l) != 0L)
1276                      jjCheckNAddStates(71, 73);
1277                   break;
1278                case 46:
1279                   if ((0x2400L & l) != 0L && kind > 56)
1280                      kind = 56;
1281                   break;
1282                case 47:
1283                   if (curChar == 10 && kind > 56)
1284                      kind = 56;
1285                   break;
1286                case 48:
1287                case 78:
1288                   if (curChar == 13)
1289                      jjCheckNAdd(47);
1290                   break;
1291                case 53:
1292                   if ((0x100000200L & l) != 0L)
1293                      jjCheckNAddStates(74, 76);
1294                   break;
1295                case 77:
1296                   if ((0x100000200L & l) != 0L)
1297                      jjCheckNAddStates(77, 79);
1298                   break;
1299                case 83:
1300                   if (curChar == 45)
1301                      jjCheckNAddStates(62, 65);
1302                   break;
1303                case 84:
1304                   if ((0x3ff000000000000L & l) == 0L)
1305                      break;
1306                   if (kind > 58)
1307                      kind = 58;
1308                   jjCheckNAddTwoStates(84, 86);
1309                   break;
1310                case 85:
1311                   if (curChar == 46 && kind > 58)
1312                      kind = 58;
1313                   break;
1314                case 86:
1315                   if (curChar == 46)
1316                      jjstateSet[jjnewStateCnt++] = 85;
1317                   break;
1318                case 87:
1319                   if ((0x3ff000000000000L & l) != 0L)
1320                      jjCheckNAddTwoStates(87, 88);
1321                   break;
1322                case 88:
1323                   if (curChar != 46)
1324                      break;
1325                   if (kind > 59)
1326                      kind = 59;
1327                   jjCheckNAddTwoStates(89, 90);
1328                   break;
1329                case 89:
1330                   if ((0x3ff000000000000L & l) == 0L)
1331                      break;
1332                   if (kind > 59)
1333                      kind = 59;
1334                   jjCheckNAddTwoStates(89, 90);
1335                   break;
1336                case 91:
1337                   if ((0x280000000000L & l) != 0L)
1338                      jjCheckNAdd(92);
1339                   break;
1340                case 92:
1341                   if ((0x3ff000000000000L & l) == 0L)
1342                      break;
1343                   if (kind > 59)
1344                      kind = 59;
1345                   jjCheckNAdd(92);
1346                   break;
1347                case 93:
1348                   if ((0x3ff000000000000L & l) != 0L)
1349                      jjCheckNAddTwoStates(93, 94);
1350                   break;
1351                case 95:
1352                   if ((0x280000000000L & l) != 0L)
1353                      jjCheckNAdd(96);
1354                   break;
1355                case 96:
1356                   if ((0x3ff000000000000L & l) == 0L)
1357                      break;
1358                   if (kind > 59)
1359                      kind = 59;
1360                   jjCheckNAdd(96);
1361                   break;
1362                case 97:
1363                   if ((0x3ff000000000000L & l) == 0L)
1364                      break;
1365                   if (kind > 58)
1366                      kind = 58;
1367                   jjCheckNAddStates(56, 61);
1368                   break;
1369                default : break;
1370             }
1371          } while(i != startsAt);
1372       }
1373       else if (curChar < 128)
1374       {
1375          long l = 1L << (curChar & 077);
1376          do
1377          {
1378             switch(jjstateSet[--i])
1379             {
1380                case 3:
1381                   if ((0x7fffffe87ffffffL & l) != 0L)
1382                   {
1383                      if (kind > 63)
1384                         kind = 63;
1385                      jjCheckNAdd(19);
1386                   }
1387                   else if (curChar == 123)
1388                      jjAddStates(80, 84);
1389                   else if (curChar == 92)
1390                      jjCheckNAddStates(85, 88);
1391                   if ((0x2000000020L & l) != 0L)
1392                      jjAddStates(89, 91);
1393                   else if ((0x20000000200L & l) != 0L)
1394                      jjstateSet[jjnewStateCnt++] = 11;
1395                   else if ((0x4000000040L & l) != 0L)
1396                      jjstateSet[jjnewStateCnt++] = 9;
1397                   else if (curChar == 123)
1398                      jjstateSet[jjnewStateCnt++] = 21;
1399                   break;
1400                case 1:
1401                   if (kind > 19)
1402                      kind = 19;
1403                   break;
1404                case 4:
1405                   if ((0x10000000100L & l) != 0L && kind > 53)
1406                      kind = 53;
1407                   break;
1408                case 5:
1409                   if ((0x800000008L & l) != 0L)
1410                      jjstateSet[jjnewStateCnt++] = 4;
1411                   break;
1412                case 6:
1413                   if ((0x200000002L & l) != 0L)
1414                      jjstateSet[jjnewStateCnt++] = 5;
1415                   break;
1416                case 7:
1417                   if ((0x2000000020L & l) != 0L)
1418                      jjstateSet[jjnewStateCnt++] = 6;
1419                   break;
1420                case 8:
1421                   if ((0x4000000040000L & l) != 0L)
1422                      jjstateSet[jjnewStateCnt++] = 7;
1423                   break;
1424                case 9:
1425                   if ((0x800000008000L & l) != 0L)
1426                      jjstateSet[jjnewStateCnt++] = 8;
1427                   break;
1428                case 10:
1429                   if ((0x4000000040L & l) != 0L)
1430                      jjstateSet[jjnewStateCnt++] = 9;
1431                   break;
1432                case 11:
1433                   if ((0x4000000040L & l) != 0L && kind > 54)
1434                      kind = 54;
1435                   break;
1436                case 12:
1437                   if ((0x20000000200L & l) != 0L)
1438                      jjstateSet[jjnewStateCnt++] = 11;
1439                   break;
1440                case 15:
1441                   if ((0x2000000020L & l) != 0L)
1442                      jjAddStates(92, 93);
1443                   break;
1444                case 18:
1445                case 19:
1446                   if ((0x7fffffe87ffffffL & l) == 0L)
1447                      break;
1448                   if (kind > 63)
1449                      kind = 63;
1450                   jjCheckNAdd(19);
1451                   break;
1452                case 20:
1453                   if (curChar == 123)
1454                      jjstateSet[jjnewStateCnt++] = 21;
1455                   break;
1456                case 21:
1457                   if ((0x7fffffe87fffffeL & l) != 0L)
1458                      jjCheckNAddTwoStates(22, 23);
1459                   break;
1460                case 22:
1461                   if ((0x7fffffe87ffffffL & l) != 0L)
1462                      jjCheckNAddTwoStates(22, 23);
1463                   break;
1464                case 23:
1465                   if (curChar == 125 && kind > 64)
1466                      kind = 64;
1467                   break;
1468                case 24:
1469                   if (curChar == 92)
1470                      jjCheckNAddStates(85, 88);
1471                   break;
1472                case 25:
1473                   if (curChar == 92)
1474                      jjCheckNAddTwoStates(25, 26);
1475                   break;
1476                case 27:
1477                   if (curChar == 92)
1478                      jjCheckNAddTwoStates(27, 28);
1479                   break;
1480                case 29:
1481                   if (curChar == 92)
1482                      jjAddStates(94, 95);
1483                   break;
1484                case 32:
1485                   if ((0x2000000020L & l) != 0L)
1486                      jjAddStates(89, 91);
1487                   break;
1488                case 33:
1489                   if ((0x1000000010L & l) == 0L)
1490                      break;
1491                   if (kind > 52)
1492                      kind = 52;
1493                   jjCheckNAddStates(68, 70);
1494                   break;
1495                case 38:
1496                   if ((0x400000004000L & l) != 0L)
1497                      jjstateSet[jjnewStateCnt++] = 33;
1498                   break;
1499                case 39:
1500                   if ((0x4000000040L & l) != 0L && kind > 55)
1501                      kind = 55;
1502                   break;
1503                case 40:
1504                   if ((0x20000000200L & l) != 0L)
1505                      jjstateSet[jjnewStateCnt++] = 39;
1506                   break;
1507                case 41:
1508                   if ((0x2000000020L & l) != 0L)
1509                      jjstateSet[jjnewStateCnt++] = 40;
1510                   break;
1511                case 42:
1512                   if ((0x8000000080000L & l) != 0L)
1513                      jjstateSet[jjnewStateCnt++] = 41;
1514                   break;
1515                case 43:
1516                   if ((0x100000001000L & l) != 0L)
1517                      jjstateSet[jjnewStateCnt++] = 42;
1518                   break;
1519                case 44:
1520                   if ((0x2000000020L & l) == 0L)
1521                      break;
1522                   if (kind > 56)
1523                      kind = 56;
1524                   jjCheckNAddStates(71, 73);
1525                   break;
1526                case 49:
1527                   if ((0x8000000080000L & l) != 0L)
1528                      jjstateSet[jjnewStateCnt++] = 44;
1529                   break;
1530                case 50:
1531                   if ((0x100000001000L & l) != 0L)
1532                      jjstateSet[jjnewStateCnt++] = 49;
1533                   break;
1534                case 51:
1535                   if (curChar == 123)
1536                      jjAddStates(80, 84);
1537                   break;
1538                case 52:
1539                   if (curChar != 125)
1540                      break;
1541                   if (kind > 52)
1542                      kind = 52;
1543                   jjCheckNAddStates(74, 76);
1544                   break;
1545                case 55:
1546                   if ((0x1000000010L & l) != 0L)
1547                      jjstateSet[jjnewStateCnt++] = 52;
1548                   break;
1549                case 56:
1550                   if ((0x400000004000L & l) != 0L)
1551                      jjstateSet[jjnewStateCnt++] = 55;
1552                   break;
1553                case 57:
1554                   if ((0x2000000020L & l) != 0L)
1555                      jjstateSet[jjnewStateCnt++] = 56;
1556                   break;
1557                case 58:
1558                   if (curChar == 125 && kind > 53)
1559                      kind = 53;
1560                   break;
1561                case 59:
1562                   if ((0x10000000100L & l) != 0L)
1563                      jjstateSet[jjnewStateCnt++] = 58;
1564                   break;
1565                case 60:
1566                   if ((0x800000008L & l) != 0L)
1567                      jjstateSet[jjnewStateCnt++] = 59;
1568                   break;
1569                case 61:
1570                   if ((0x200000002L & l) != 0L)
1571                      jjstateSet[jjnewStateCnt++] = 60;
1572                   break;
1573                case 62:
1574                   if ((0x2000000020L & l) != 0L)
1575                      jjstateSet[jjnewStateCnt++] = 61;
1576                   break;
1577                case 63:
1578                   if ((0x4000000040000L & l) != 0L)
1579                      jjstateSet[jjnewStateCnt++] = 62;
1580                   break;
1581                case 64:
1582                   if ((0x800000008000L & l) != 0L)
1583                      jjstateSet[jjnewStateCnt++] = 63;
1584                   break;
1585                case 65:
1586                   if ((0x4000000040L & l) != 0L)
1587                      jjstateSet[jjnewStateCnt++] = 64;
1588                   break;
1589                case 66:
1590                   if (curChar == 125 && kind > 54)
1591                      kind = 54;
1592                   break;
1593                case 67:
1594                   if ((0x4000000040L & l) != 0L)
1595                      jjstateSet[jjnewStateCnt++] = 66;
1596                   break;
1597                case 68:
1598                   if ((0x20000000200L & l) != 0L)
1599                      jjstateSet[jjnewStateCnt++] = 67;
1600                   break;
1601                case 69:
1602                   if (curChar == 125 && kind > 55)
1603                      kind = 55;
1604                   break;
1605                case 70:
1606                   if ((0x4000000040L & l) != 0L)
1607                      jjstateSet[jjnewStateCnt++] = 69;
1608                   break;
1609                case 71:
1610                   if ((0x20000000200L & l) != 0L)
1611                      jjstateSet[jjnewStateCnt++] = 70;
1612                   break;
1613                case 72:
1614                   if ((0x2000000020L & l) != 0L)
1615                      jjstateSet[jjnewStateCnt++] = 71;
1616                   break;
1617                case 73:
1618                   if ((0x8000000080000L & l) != 0L)
1619                      jjstateSet[jjnewStateCnt++] = 72;
1620                   break;
1621                case 74:
1622                   if ((0x100000001000L & l) != 0L)
1623                      jjstateSet[jjnewStateCnt++] = 73;
1624                   break;
1625                case 75:
1626                   if ((0x2000000020L & l) != 0L)
1627                      jjstateSet[jjnewStateCnt++] = 74;
1628                   break;
1629                case 76:
1630                   if (curChar != 125)
1631                      break;
1632                   if (kind > 56)
1633                      kind = 56;
1634                   jjCheckNAddStates(77, 79);
1635                   break;
1636                case 79:
1637                   if ((0x2000000020L & l) != 0L)
1638                      jjstateSet[jjnewStateCnt++] = 76;
1639                   break;
1640                case 80:
1641                   if ((0x8000000080000L & l) != 0L)
1642                      jjstateSet[jjnewStateCnt++] = 79;
1643                   break;
1644                case 81:
1645                   if ((0x100000001000L & l) != 0L)
1646                      jjstateSet[jjnewStateCnt++] = 80;
1647                   break;
1648                case 82:
1649                   if ((0x2000000020L & l) != 0L)
1650                      jjstateSet[jjnewStateCnt++] = 81;
1651                   break;
1652                case 90:
1653                   if ((0x2000000020L & l) != 0L)
1654                      jjAddStates(96, 97);
1655                   break;
1656                case 94:
1657                   if ((0x2000000020L & l) != 0L)
1658                      jjAddStates(98, 99);
1659                   break;
1660                default : break;
1661             }
1662          } while(i != startsAt);
1663       }
1664       else
1665       {
1666          int hiByte = (int)(curChar >> 8);
1667          int i1 = hiByte >> 6;
1668          long l1 = 1L << (hiByte & 077);
1669          int i2 = (curChar & 0xff) >> 6;
1670          long l2 = 1L << (curChar & 077);
1671          do
1672          {
1673             switch(jjstateSet[--i])
1674             {
1675                case 1:
1676                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
1677                      kind = 19;
1678                   break;
1679                default : break;
1680             }
1681          } while(i != startsAt);
1682       }
1683       if (kind != 0x7fffffff)
1684       {
1685          jjmatchedKind = kind;
1686          jjmatchedPos = curPos;
1687          kind = 0x7fffffff;
1688       }
1689       ++curPos;
1690       if ((i = jjnewStateCnt) == (startsAt = 98 - (jjnewStateCnt = startsAt)))
1691          return curPos;
1692       try { curChar = input_stream.readChar(); }
1693       catch(java.io.IOException e) { return curPos; }
1694    }
1695 }
1696 private final int jjStopStringLiteralDfa_8(int pos, long active0)
1697 {
1698    switch (pos)
1699    {
1700       case 0:
1701          if ((active0 & 0x340000L) != 0L)
1702             return 2;
1703          return -1;
1704       case 1:
1705          if ((active0 & 0x100000L) != 0L)
1706             return 0;
1707          return -1;
1708       default :
1709          return -1;
1710    }
1711 }
1712 private final int jjStartNfa_8(int pos, long active0)
1713 {
1714    return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
1715 }
1716 private int jjMoveStringLiteralDfa0_8()
1717 {
1718    switch(curChar)
1719    {
1720       case 35:
1721          jjmatchedKind = 21;
1722          return jjMoveStringLiteralDfa1_8(0x140000L);
1723       case 42:
1724          return jjMoveStringLiteralDfa1_8(0x10000000L);
1725       default :
1726          return jjMoveNfa_8(3, 0);
1727    }
1728 }
1729 private int jjMoveStringLiteralDfa1_8(long active0)
1730 {
1731    try { curChar = input_stream.readChar(); }
1732    catch(java.io.IOException e) {
1733       jjStopStringLiteralDfa_8(0, active0);
1734       return 1;
1735    }
1736    switch(curChar)
1737    {
1738       case 35:
1739          if ((active0 & 0x10000000L) != 0L)
1740             return jjStopAtPos(1, 28);
1741          break;
1742       case 42:
1743          if ((active0 & 0x100000L) != 0L)
1744             return jjStartNfaWithStates_8(1, 20, 0);
1745          break;
1746       case 91:
1747          return jjMoveStringLiteralDfa2_8(active0, 0x40000L);
1748       default :
1749          break;
1750    }
1751    return jjStartNfa_8(0, active0);
1752 }
1753 private int jjMoveStringLiteralDfa2_8(long old0, long active0)
1754 {
1755    if (((active0 &= old0)) == 0L)
1756       return jjStartNfa_8(0, old0);
1757    try { curChar = input_stream.readChar(); }
1758    catch(java.io.IOException e) {
1759       jjStopStringLiteralDfa_8(1, active0);
1760       return 2;
1761    }
1762    switch(curChar)
1763    {
1764       case 91:
1765          if ((active0 & 0x40000L) != 0L)
1766             return jjStopAtPos(2, 18);
1767          break;
1768       default :
1769          break;
1770    }
1771    return jjStartNfa_8(1, active0);
1772 }
1773 private int jjStartNfaWithStates_8(int pos, int kind, int state)
1774 {
1775    jjmatchedKind = kind;
1776    jjmatchedPos = pos;
1777    try { curChar = input_stream.readChar(); }
1778    catch(java.io.IOException e) { return pos + 1; }
1779    return jjMoveNfa_8(state, pos + 1);
1780 }
1781 private int jjMoveNfa_8(int startState, int curPos)
1782 {
1783    int startsAt = 0;
1784    jjnewStateCnt = 12;
1785    int i = 1;
1786    jjstateSet[0] = startState;
1787    int kind = 0x7fffffff;
1788    for (;;)
1789    {
1790       if (++jjround == 0x7fffffff)
1791          ReInitRounds();
1792       if (curChar < 64)
1793       {
1794          long l = 1L << curChar;
1795          do
1796          {
1797             switch(jjstateSet[--i])
1798             {
1799                case 3:
1800                   if (curChar == 36)
1801                   {
1802                      if (kind > 16)
1803                         kind = 16;
1804                      jjCheckNAddTwoStates(9, 10);
1805                   }
1806                   else if (curChar == 35)
1807                      jjstateSet[jjnewStateCnt++] = 2;
1808                   break;
1809                case 0:
1810                   if (curChar == 42)
1811                      jjstateSet[jjnewStateCnt++] = 1;
1812                   break;
1813                case 1:
1814                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
1815                      kind = 19;
1816                   break;
1817                case 2:
1818                   if (curChar == 42)
1819                      jjstateSet[jjnewStateCnt++] = 0;
1820                   break;
1821                case 6:
1822                   if (curChar == 36 && kind > 16)
1823                      kind = 16;
1824                   break;
1825                case 8:
1826                   if (curChar == 36)
1827                      jjCheckNAddTwoStates(9, 10);
1828                   break;
1829                case 10:
1830                   if (curChar == 33 && kind > 17)
1831                      kind = 17;
1832                   break;
1833                case 11:
1834                   if (curChar != 36)
1835                      break;
1836                   if (kind > 16)
1837                      kind = 16;
1838                   jjCheckNAddTwoStates(9, 10);
1839                   break;
1840                default : break;
1841             }
1842          } while(i != startsAt);
1843       }
1844       else if (curChar < 128)
1845       {
1846          long l = 1L << (curChar & 077);
1847          do
1848          {
1849             switch(jjstateSet[--i])
1850             {
1851                case 3:
1852                   if (curChar == 92)
1853                      jjCheckNAddStates(100, 103);
1854                   break;
1855                case 1:
1856                   if (kind > 19)
1857                      kind = 19;
1858                   break;
1859                case 5:
1860                   if (curChar == 92)
1861                      jjCheckNAddTwoStates(5, 6);
1862                   break;
1863                case 7:
1864                   if (curChar == 92)
1865                      jjCheckNAddTwoStates(7, 8);
1866                   break;
1867                case 9:
1868                   if (curChar == 92)
1869                      jjAddStates(104, 105);
1870                   break;
1871                default : break;
1872             }
1873          } while(i != startsAt);
1874       }
1875       else
1876       {
1877          int hiByte = (int)(curChar >> 8);
1878          int i1 = hiByte >> 6;
1879          long l1 = 1L << (hiByte & 077);
1880          int i2 = (curChar & 0xff) >> 6;
1881          long l2 = 1L << (curChar & 077);
1882          do
1883          {
1884             switch(jjstateSet[--i])
1885             {
1886                case 1:
1887                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
1888                      kind = 19;
1889                   break;
1890                default : break;
1891             }
1892          } while(i != startsAt);
1893       }
1894       if (kind != 0x7fffffff)
1895       {
1896          jjmatchedKind = kind;
1897          jjmatchedPos = curPos;
1898          kind = 0x7fffffff;
1899       }
1900       ++curPos;
1901       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
1902          return curPos;
1903       try { curChar = input_stream.readChar(); }
1904       catch(java.io.IOException e) { return curPos; }
1905    }
1906 }
1907 private final int jjStopStringLiteralDfa_6(int pos, long active0)
1908 {
1909    switch (pos)
1910    {
1911       case 0:
1912          if ((active0 & 0x340000L) != 0L)
1913             return 2;
1914          return -1;
1915       case 1:
1916          if ((active0 & 0x100000L) != 0L)
1917             return 0;
1918          return -1;
1919       default :
1920          return -1;
1921    }
1922 }
1923 private final int jjStartNfa_6(int pos, long active0)
1924 {
1925    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0), pos + 1);
1926 }
1927 private int jjMoveStringLiteralDfa0_6()
1928 {
1929    switch(curChar)
1930    {
1931       case 35:
1932          jjmatchedKind = 21;
1933          return jjMoveStringLiteralDfa1_6(0x140000L);
1934       default :
1935          return jjMoveNfa_6(3, 0);
1936    }
1937 }
1938 private int jjMoveStringLiteralDfa1_6(long active0)
1939 {
1940    try { curChar = input_stream.readChar(); }
1941    catch(java.io.IOException e) {
1942       jjStopStringLiteralDfa_6(0, active0);
1943       return 1;
1944    }
1945    switch(curChar)
1946    {
1947       case 42:
1948          if ((active0 & 0x100000L) != 0L)
1949             return jjStartNfaWithStates_6(1, 20, 0);
1950          break;
1951       case 91:
1952          return jjMoveStringLiteralDfa2_6(active0, 0x40000L);
1953       default :
1954          break;
1955    }
1956    return jjStartNfa_6(0, active0);
1957 }
1958 private int jjMoveStringLiteralDfa2_6(long old0, long active0)
1959 {
1960    if (((active0 &= old0)) == 0L)
1961       return jjStartNfa_6(0, old0);
1962    try { curChar = input_stream.readChar(); }
1963    catch(java.io.IOException e) {
1964       jjStopStringLiteralDfa_6(1, active0);
1965       return 2;
1966    }
1967    switch(curChar)
1968    {
1969       case 91:
1970          if ((active0 & 0x40000L) != 0L)
1971             return jjStopAtPos(2, 18);
1972          break;
1973       default :
1974          break;
1975    }
1976    return jjStartNfa_6(1, active0);
1977 }
1978 private int jjStartNfaWithStates_6(int pos, int kind, int state)
1979 {
1980    jjmatchedKind = kind;
1981    jjmatchedPos = pos;
1982    try { curChar = input_stream.readChar(); }
1983    catch(java.io.IOException e) { return pos + 1; }
1984    return jjMoveNfa_6(state, pos + 1);
1985 }
1986 private int jjMoveNfa_6(int startState, int curPos)
1987 {
1988    int startsAt = 0;
1989    jjnewStateCnt = 12;
1990    int i = 1;
1991    jjstateSet[0] = startState;
1992    int kind = 0x7fffffff;
1993    for (;;)
1994    {
1995       if (++jjround == 0x7fffffff)
1996          ReInitRounds();
1997       if (curChar < 64)
1998       {
1999          long l = 1L << curChar;
2000          do
2001          {
2002             switch(jjstateSet[--i])
2003             {
2004                case 3:
2005                   if (curChar == 36)
2006                   {
2007                      if (kind > 16)
2008                         kind = 16;
2009                      jjCheckNAddTwoStates(9, 10);
2010                   }
2011                   else if (curChar == 35)
2012                      jjstateSet[jjnewStateCnt++] = 2;
2013                   break;
2014                case 0:
2015                   if (curChar == 42)
2016                      jjstateSet[jjnewStateCnt++] = 1;
2017                   break;
2018                case 1:
2019                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2020                      kind = 19;
2021                   break;
2022                case 2:
2023                   if (curChar == 42)
2024                      jjstateSet[jjnewStateCnt++] = 0;
2025                   break;
2026                case 6:
2027                   if (curChar == 36 && kind > 16)
2028                      kind = 16;
2029                   break;
2030                case 8:
2031                   if (curChar == 36)
2032                      jjCheckNAddTwoStates(9, 10);
2033                   break;
2034                case 10:
2035                   if (curChar == 33 && kind > 17)
2036                      kind = 17;
2037                   break;
2038                case 11:
2039                   if (curChar != 36)
2040                      break;
2041                   if (kind > 16)
2042                      kind = 16;
2043                   jjCheckNAddTwoStates(9, 10);
2044                   break;
2045                default : break;
2046             }
2047          } while(i != startsAt);
2048       }
2049       else if (curChar < 128)
2050       {
2051          long l = 1L << (curChar & 077);
2052          do
2053          {
2054             switch(jjstateSet[--i])
2055             {
2056                case 3:
2057                   if (curChar == 92)
2058                      jjCheckNAddStates(100, 103);
2059                   break;
2060                case 1:
2061                   if (kind > 19)
2062                      kind = 19;
2063                   break;
2064                case 5:
2065                   if (curChar == 92)
2066                      jjCheckNAddTwoStates(5, 6);
2067                   break;
2068                case 7:
2069                   if (curChar == 92)
2070                      jjCheckNAddTwoStates(7, 8);
2071                   break;
2072                case 9:
2073                   if (curChar == 92)
2074                      jjAddStates(104, 105);
2075                   break;
2076                default : break;
2077             }
2078          } while(i != startsAt);
2079       }
2080       else
2081       {
2082          int hiByte = (int)(curChar >> 8);
2083          int i1 = hiByte >> 6;
2084          long l1 = 1L << (hiByte & 077);
2085          int i2 = (curChar & 0xff) >> 6;
2086          long l2 = 1L << (curChar & 077);
2087          do
2088          {
2089             switch(jjstateSet[--i])
2090             {
2091                case 1:
2092                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
2093                      kind = 19;
2094                   break;
2095                default : break;
2096             }
2097          } while(i != startsAt);
2098       }
2099       if (kind != 0x7fffffff)
2100       {
2101          jjmatchedKind = kind;
2102          jjmatchedPos = curPos;
2103          kind = 0x7fffffff;
2104       }
2105       ++curPos;
2106       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
2107          return curPos;
2108       try { curChar = input_stream.readChar(); }
2109       catch(java.io.IOException e) { return curPos; }
2110    }
2111 }
2112 private final int jjStopStringLiteralDfa_5(int pos, long active0)
2113 {
2114    switch (pos)
2115    {
2116       case 0:
2117          if ((active0 & 0x1800000L) != 0L)
2118             return 20;
2119          if ((active0 & 0x740000L) != 0L)
2120             return 39;
2121          return -1;
2122       case 1:
2123          if ((active0 & 0x800000L) != 0L)
2124             return 40;
2125          if ((active0 & 0x100000L) != 0L)
2126             return 37;
2127          return -1;
2128       default :
2129          return -1;
2130    }
2131 }
2132 private final int jjStartNfa_5(int pos, long active0)
2133 {
2134    return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
2135 }
2136 private int jjMoveStringLiteralDfa0_5()
2137 {
2138    switch(curChar)
2139    {
2140       case 35:
2141          jjmatchedKind = 21;
2142          return jjMoveStringLiteralDfa1_5(0x540000L);
2143       case 92:
2144          jjmatchedKind = 24;
2145          return jjMoveStringLiteralDfa1_5(0x800000L);
2146       default :
2147          return jjMoveNfa_5(13, 0);
2148    }
2149 }
2150 private int jjMoveStringLiteralDfa1_5(long active0)
2151 {
2152    try { curChar = input_stream.readChar(); }
2153    catch(java.io.IOException e) {
2154       jjStopStringLiteralDfa_5(0, active0);
2155       return 1;
2156    }
2157    switch(curChar)
2158    {
2159       case 35:
2160          if ((active0 & 0x400000L) != 0L)
2161             return jjStopAtPos(1, 22);
2162          break;
2163       case 42:
2164          if ((active0 & 0x100000L) != 0L)
2165             return jjStartNfaWithStates_5(1, 20, 37);
2166          break;
2167       case 91:
2168          return jjMoveStringLiteralDfa2_5(active0, 0x40000L);
2169       case 92:
2170          if ((active0 & 0x800000L) != 0L)
2171             return jjStartNfaWithStates_5(1, 23, 40);
2172          break;
2173       default :
2174          break;
2175    }
2176    return jjStartNfa_5(0, active0);
2177 }
2178 private int jjMoveStringLiteralDfa2_5(long old0, long active0)
2179 {
2180    if (((active0 &= old0)) == 0L)
2181       return jjStartNfa_5(0, old0);
2182    try { curChar = input_stream.readChar(); }
2183    catch(java.io.IOException e) {
2184       jjStopStringLiteralDfa_5(1, active0);
2185       return 2;
2186    }
2187    switch(curChar)
2188    {
2189       case 91:
2190          if ((active0 & 0x40000L) != 0L)
2191             return jjStopAtPos(2, 18);
2192          break;
2193       default :
2194          break;
2195    }
2196    return jjStartNfa_5(1, active0);
2197 }
2198 private int jjStartNfaWithStates_5(int pos, int kind, int state)
2199 {
2200    jjmatchedKind = kind;
2201    jjmatchedPos = pos;
2202    try { curChar = input_stream.readChar(); }
2203    catch(java.io.IOException e) { return pos + 1; }
2204    return jjMoveNfa_5(state, pos + 1);
2205 }
2206 private int jjMoveNfa_5(int startState, int curPos)
2207 {
2208    int startsAt = 0;
2209    jjnewStateCnt = 40;
2210    int i = 1;
2211    jjstateSet[0] = startState;
2212    int kind = 0x7fffffff;
2213    for (;;)
2214    {
2215       if (++jjround == 0x7fffffff)
2216          ReInitRounds();
2217       if (curChar < 64)
2218       {
2219          long l = 1L << curChar;
2220          do
2221          {
2222             switch(jjstateSet[--i])
2223             {
2224                case 39:
2225                   if (curChar == 42)
2226                      jjstateSet[jjnewStateCnt++] = 37;
2227                   break;
2228                case 40:
2229                   if (curChar == 36)
2230                      jjCheckNAddTwoStates(33, 34);
2231                   if (curChar == 36)
2232                   {
2233                      if (kind > 16)
2234                         kind = 16;
2235                   }
2236                   break;
2237                case 13:
2238                   if ((0xffffffe7ffffffffL & l) != 0L)
2239                   {
2240                      if (kind > 25)
2241                         kind = 25;
2242                      jjCheckNAdd(12);
2243                   }
2244                   else if (curChar == 35)
2245                      jjCheckNAddStates(106, 108);
2246                   else if (curChar == 36)
2247                   {
2248                      if (kind > 16)
2249                         kind = 16;
2250                      jjCheckNAddTwoStates(33, 34);
2251                   }
2252                   if ((0x100000200L & l) != 0L)
2253                      jjCheckNAddTwoStates(0, 1);
2254                   else if (curChar == 36)
2255                      jjCheckNAddStates(109, 112);
2256                   break;
2257                case 20:
2258                   if (curChar == 36)
2259                      jjCheckNAddTwoStates(33, 34);
2260                   else if (curChar == 35)
2261                      jjAddStates(113, 114);
2262                   if (curChar == 36)
2263                   {
2264                      if (kind > 16)
2265                         kind = 16;
2266                   }
2267                   break;
2268                case 0:
2269                   if ((0x100000200L & l) != 0L)
2270                      jjCheckNAddTwoStates(0, 1);
2271                   break;
2272                case 1:
2273                   if (curChar == 35)
2274                      jjCheckNAddTwoStates(6, 11);
2275                   break;
2276                case 3:
2277                   if (curChar == 32)
2278                      jjAddStates(115, 116);
2279                   break;
2280                case 4:
2281                   if (curChar == 40 && kind > 15)
2282                      kind = 15;
2283                   break;
2284                case 12:
2285                   if ((0xffffffe7ffffffffL & l) == 0L)
2286                      break;
2287                   if (kind > 25)
2288                      kind = 25;
2289                   jjCheckNAdd(12);
2290                   break;
2291                case 15:
2292                case 16:
2293                   if (curChar == 33)
2294                      jjCheckNAdd(14);
2295                   break;
2296                case 18:
2297                   if (curChar == 46 && kind > 74)
2298                      kind = 74;
2299                   break;
2300                case 21:
2301                   if (curChar == 35)
2302                      jjAddStates(113, 114);
2303                   break;
2304                case 23:
2305                   if ((0x3ff000000000000L & l) == 0L)
2306                      break;
2307                   if (kind > 14)
2308                      kind = 14;
2309                   jjstateSet[jjnewStateCnt++] = 23;
2310                   break;
2311                case 26:
2312                   if ((0x3ff000000000000L & l) != 0L)
2313                      jjAddStates(26, 27);
2314                   break;
2315                case 30:
2316                   if (curChar == 36 && kind > 16)
2317                      kind = 16;
2318                   break;
2319                case 32:
2320                   if (curChar == 36)
2321                      jjCheckNAddTwoStates(33, 34);
2322                   break;
2323                case 34:
2324                   if (curChar == 33 && kind > 17)
2325                      kind = 17;
2326                   break;
2327                case 35:
2328                   if (curChar != 36)
2329                      break;
2330                   if (kind > 16)
2331                      kind = 16;
2332                   jjCheckNAddTwoStates(33, 34);
2333                   break;
2334                case 36:
2335                   if (curChar == 35)
2336                      jjCheckNAddStates(106, 108);
2337                   break;
2338                case 37:
2339                   if (curChar == 42)
2340                      jjstateSet[jjnewStateCnt++] = 38;
2341                   break;
2342                case 38:
2343                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2344                      kind = 19;
2345                   break;
2346                default : break;
2347             }
2348          } while(i != startsAt);
2349       }
2350       else if (curChar < 128)
2351       {
2352          long l = 1L << (curChar & 077);
2353          do
2354          {
2355             switch(jjstateSet[--i])
2356             {
2357                case 39:
2358                   if ((0x8000000080000L & l) != 0L)
2359                      jjstateSet[jjnewStateCnt++] = 5;
2360                   else if (curChar == 123)
2361                      jjstateSet[jjnewStateCnt++] = 10;
2362                   break;
2363                case 40:
2364                   if (curChar == 92)
2365                      jjAddStates(117, 118);
2366                   if (curChar == 92)
2367                      jjCheckNAddTwoStates(31, 32);
2368                   if (curChar == 92)
2369                      jjCheckNAddTwoStates(29, 30);
2370                   break;
2371                case 13:
2372                   if ((0xffffffffefffffffL & l) != 0L)
2373                   {
2374                      if (kind > 25)
2375                         kind = 25;
2376                      jjCheckNAdd(12);
2377                   }
2378                   else if (curChar == 92)
2379                      jjCheckNAddStates(119, 122);
2380                   if (curChar == 92)
2381                      jjAddStates(117, 118);
2382                   break;
2383                case 20:
2384                   if (curChar == 92)
2385                      jjCheckNAddTwoStates(31, 32);
2386                   if (curChar == 92)
2387                      jjCheckNAddTwoStates(29, 30);
2388                   if (curChar == 92)
2389                      jjstateSet[jjnewStateCnt++] = 19;
2390                   break;
2391                case 2:
2392                   if ((0x10000000100000L & l) != 0L)
2393                      jjCheckNAddTwoStates(3, 4);
2394                   break;
2395                case 5:
2396                   if ((0x2000000020L & l) != 0L)
2397                      jjstateSet[jjnewStateCnt++] = 2;
2398                   break;
2399                case 6:
2400                   if ((0x8000000080000L & l) != 0L)
2401                      jjstateSet[jjnewStateCnt++] = 5;
2402                   break;
2403                case 7:
2404                   if (curChar == 125)
2405                      jjCheckNAddTwoStates(3, 4);
2406                   break;
2407                case 8:
2408                   if ((0x10000000100000L & l) != 0L)
2409                      jjstateSet[jjnewStateCnt++] = 7;
2410                   break;
2411                case 9:
2412                   if ((0x2000000020L & l) != 0L)
2413                      jjstateSet[jjnewStateCnt++] = 8;
2414                   break;
2415                case 10:
2416                   if ((0x8000000080000L & l) != 0L)
2417                      jjstateSet[jjnewStateCnt++] = 9;
2418                   break;
2419                case 11:
2420                   if (curChar == 123)
2421                      jjstateSet[jjnewStateCnt++] = 10;
2422                   break;
2423                case 12:
2424                   if ((0xffffffffefffffffL & l) == 0L)
2425                      break;
2426                   if (kind > 25)
2427                      kind = 25;
2428                   jjCheckNAdd(12);
2429                   break;
2430                case 14:
2431                   if (curChar == 91 && kind > 74)
2432                      kind = 74;
2433                   break;
2434                case 17:
2435                   if (curChar == 92)
2436                      jjstateSet[jjnewStateCnt++] = 16;
2437                   break;
2438                case 19:
2439                   if (curChar == 92)
2440                      jjAddStates(117, 118);
2441                   break;
2442                case 22:
2443                case 23:
2444                   if ((0x7fffffe87ffffffL & l) == 0L)
2445                      break;
2446                   if (kind > 14)
2447                      kind = 14;
2448                   jjCheckNAdd(23);
2449                   break;
2450                case 24:
2451                   if (curChar == 123)
2452                      jjstateSet[jjnewStateCnt++] = 25;
2453                   break;
2454                case 25:
2455                   if ((0x7fffffe87fffffeL & l) != 0L)
2456                      jjCheckNAddTwoStates(26, 27);
2457                   break;
2458                case 26:
2459                   if ((0x7fffffe87ffffffL & l) != 0L)
2460                      jjCheckNAddTwoStates(26, 27);
2461                   break;
2462                case 27:
2463                   if (curChar == 125 && kind > 14)
2464                      kind = 14;
2465                   break;
2466                case 28:
2467                   if (curChar == 92)
2468                      jjCheckNAddStates(119, 122);
2469                   break;
2470                case 29:
2471                   if (curChar == 92)
2472                      jjCheckNAddTwoStates(29, 30);
2473                   break;
2474                case 31:
2475                   if (curChar == 92)
2476                      jjCheckNAddTwoStates(31, 32);
2477                   break;
2478                case 33:
2479                   if (curChar == 92)
2480                      jjAddStates(28, 29);
2481                   break;
2482                case 38:
2483                   if (kind > 19)
2484                      kind = 19;
2485                   break;
2486                default : break;
2487             }
2488          } while(i != startsAt);
2489       }
2490       else
2491       {
2492          int hiByte = (int)(curChar >> 8);
2493          int i1 = hiByte >> 6;
2494          long l1 = 1L << (hiByte & 077);
2495          int i2 = (curChar & 0xff) >> 6;
2496          long l2 = 1L << (curChar & 077);
2497          do
2498          {
2499             switch(jjstateSet[--i])
2500             {
2501                case 13:
2502                case 12:
2503                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
2504                      break;
2505                   if (kind > 25)
2506                      kind = 25;
2507                   jjCheckNAdd(12);
2508                   break;
2509                case 38:
2510                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
2511                      kind = 19;
2512                   break;
2513                default : break;
2514             }
2515          } while(i != startsAt);
2516       }
2517       if (kind != 0x7fffffff)
2518       {
2519          jjmatchedKind = kind;
2520          jjmatchedPos = curPos;
2521          kind = 0x7fffffff;
2522       }
2523       ++curPos;
2524       if ((i = jjnewStateCnt) == (startsAt = 40 - (jjnewStateCnt = startsAt)))
2525          return curPos;
2526       try { curChar = input_stream.readChar(); }
2527       catch(java.io.IOException e) { return curPos; }
2528    }
2529 }
2530 private final int jjStopStringLiteralDfa_9(int pos, long active0)
2531 {
2532    switch (pos)
2533    {
2534       case 0:
2535          if ((active0 & 0x340000L) != 0L)
2536             return 2;
2537          return -1;
2538       case 1:
2539          if ((active0 & 0x100000L) != 0L)
2540             return 0;
2541          return -1;
2542       default :
2543          return -1;
2544    }
2545 }
2546 private final int jjStartNfa_9(int pos, long active0)
2547 {
2548    return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0), pos + 1);
2549 }
2550 private int jjMoveStringLiteralDfa0_9()
2551 {
2552    switch(curChar)
2553    {
2554       case 35:
2555          jjmatchedKind = 21;
2556          return jjMoveStringLiteralDfa1_9(0x140000L);
2557       case 42:
2558          return jjMoveStringLiteralDfa1_9(0x8000000L);
2559       default :
2560          return jjMoveNfa_9(3, 0);
2561    }
2562 }
2563 private int jjMoveStringLiteralDfa1_9(long active0)
2564 {
2565    try { curChar = input_stream.readChar(); }
2566    catch(java.io.IOException e) {
2567       jjStopStringLiteralDfa_9(0, active0);
2568       return 1;
2569    }
2570    switch(curChar)
2571    {
2572       case 35:
2573          if ((active0 & 0x8000000L) != 0L)
2574             return jjStopAtPos(1, 27);
2575          break;
2576       case 42:
2577          if ((active0 & 0x100000L) != 0L)
2578             return jjStartNfaWithStates_9(1, 20, 0);
2579          break;
2580       case 91:
2581          return jjMoveStringLiteralDfa2_9(active0, 0x40000L);
2582       default :
2583          break;
2584    }
2585    return jjStartNfa_9(0, active0);
2586 }
2587 private int jjMoveStringLiteralDfa2_9(long old0, long active0)
2588 {
2589    if (((active0 &= old0)) == 0L)
2590       return jjStartNfa_9(0, old0);
2591    try { curChar = input_stream.readChar(); }
2592    catch(java.io.IOException e) {
2593       jjStopStringLiteralDfa_9(1, active0);
2594       return 2;
2595    }
2596    switch(curChar)
2597    {
2598       case 91:
2599          if ((active0 & 0x40000L) != 0L)
2600             return jjStopAtPos(2, 18);
2601          break;
2602       default :
2603          break;
2604    }
2605    return jjStartNfa_9(1, active0);
2606 }
2607 private int jjStartNfaWithStates_9(int pos, int kind, int state)
2608 {
2609    jjmatchedKind = kind;
2610    jjmatchedPos = pos;
2611    try { curChar = input_stream.readChar(); }
2612    catch(java.io.IOException e) { return pos + 1; }
2613    return jjMoveNfa_9(state, pos + 1);
2614 }
2615 private int jjMoveNfa_9(int startState, int curPos)
2616 {
2617    int startsAt = 0;
2618    jjnewStateCnt = 12;
2619    int i = 1;
2620    jjstateSet[0] = startState;
2621    int kind = 0x7fffffff;
2622    for (;;)
2623    {
2624       if (++jjround == 0x7fffffff)
2625          ReInitRounds();
2626       if (curChar < 64)
2627       {
2628          long l = 1L << curChar;
2629          do
2630          {
2631             switch(jjstateSet[--i])
2632             {
2633                case 3:
2634                   if (curChar == 36)
2635                   {
2636                      if (kind > 16)
2637                         kind = 16;
2638                      jjCheckNAddTwoStates(9, 10);
2639                   }
2640                   else if (curChar == 35)
2641                      jjstateSet[jjnewStateCnt++] = 2;
2642                   break;
2643                case 0:
2644                   if (curChar == 42)
2645                      jjstateSet[jjnewStateCnt++] = 1;
2646                   break;
2647                case 1:
2648                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2649                      kind = 19;
2650                   break;
2651                case 2:
2652                   if (curChar == 42)
2653                      jjstateSet[jjnewStateCnt++] = 0;
2654                   break;
2655                case 6:
2656                   if (curChar == 36 && kind > 16)
2657                      kind = 16;
2658                   break;
2659                case 8:
2660                   if (curChar == 36)
2661                      jjCheckNAddTwoStates(9, 10);
2662                   break;
2663                case 10:
2664                   if (curChar == 33 && kind > 17)
2665                      kind = 17;
2666                   break;
2667                case 11:
2668                   if (curChar != 36)
2669                      break;
2670                   if (kind > 16)
2671                      kind = 16;
2672                   jjCheckNAddTwoStates(9, 10);
2673                   break;
2674                default : break;
2675             }
2676          } while(i != startsAt);
2677       }
2678       else if (curChar < 128)
2679       {
2680          long l = 1L << (curChar & 077);
2681          do
2682          {
2683             switch(jjstateSet[--i])
2684             {
2685                case 3:
2686                   if (curChar == 92)
2687                      jjCheckNAddStates(100, 103);
2688                   break;
2689                case 1:
2690                   if (kind > 19)
2691                      kind = 19;
2692                   break;
2693                case 5:
2694                   if (curChar == 92)
2695                      jjCheckNAddTwoStates(5, 6);
2696                   break;
2697                case 7:
2698                   if (curChar == 92)
2699                      jjCheckNAddTwoStates(7, 8);
2700                   break;
2701                case 9:
2702                   if (curChar == 92)
2703                      jjAddStates(104, 105);
2704                   break;
2705                default : break;
2706             }
2707          } while(i != startsAt);
2708       }
2709       else
2710       {
2711          int hiByte = (int)(curChar >> 8);
2712          int i1 = hiByte >> 6;
2713          long l1 = 1L << (hiByte & 077);
2714          int i2 = (curChar & 0xff) >> 6;
2715          long l2 = 1L << (curChar & 077);
2716          do
2717          {
2718             switch(jjstateSet[--i])
2719             {
2720                case 1:
2721                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
2722                      kind = 19;
2723                   break;
2724                default : break;
2725             }
2726          } while(i != startsAt);
2727       }
2728       if (kind != 0x7fffffff)
2729       {
2730          jjmatchedKind = kind;
2731          jjmatchedPos = curPos;
2732          kind = 0x7fffffff;
2733       }
2734       ++curPos;
2735       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
2736          return curPos;
2737       try { curChar = input_stream.readChar(); }
2738       catch(java.io.IOException e) { return curPos; }
2739    }
2740 }
2741 private final int jjStopStringLiteralDfa_2(int pos, long active0)
2742 {
2743    switch (pos)
2744    {
2745       case 0:
2746          if ((active0 & 0x340000L) != 0L)
2747             return 2;
2748          return -1;
2749       case 1:
2750          if ((active0 & 0x100000L) != 0L)
2751             return 0;
2752          return -1;
2753       default :
2754          return -1;
2755    }
2756 }
2757 private final int jjStartNfa_2(int pos, long active0)
2758 {
2759    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
2760 }
2761 private int jjMoveStringLiteralDfa0_2()
2762 {
2763    switch(curChar)
2764    {
2765       case 35:
2766          jjmatchedKind = 21;
2767          return jjMoveStringLiteralDfa1_2(0x140000L);
2768       case 93:
2769          return jjStopAtPos(0, 2);
2770       case 70:
2771       case 102:
2772          return jjMoveStringLiteralDfa1_2(0x800000000L);
2773       case 84:
2774       case 116:
2775          return jjMoveStringLiteralDfa1_2(0x400000000L);
2776       default :
2777          return jjMoveNfa_2(3, 0);
2778    }
2779 }
2780 private int jjMoveStringLiteralDfa1_2(long active0)
2781 {
2782    try { curChar = input_stream.readChar(); }
2783    catch(java.io.IOException e) {
2784       jjStopStringLiteralDfa_2(0, active0);
2785       return 1;
2786    }
2787    switch(curChar)
2788    {
2789       case 42:
2790          if ((active0 & 0x100000L) != 0L)
2791             return jjStartNfaWithStates_2(1, 20, 0);
2792          break;
2793       case 91:
2794          return jjMoveStringLiteralDfa2_2(active0, 0x40000L);
2795       case 65:
2796       case 97:
2797          return jjMoveStringLiteralDfa2_2(active0, 0x800000000L);
2798       case 82:
2799       case 114:
2800          return jjMoveStringLiteralDfa2_2(active0, 0x400000000L);
2801       default :
2802          break;
2803    }
2804    return jjStartNfa_2(0, active0);
2805 }
2806 private int jjMoveStringLiteralDfa2_2(long old0, long active0)
2807 {
2808    if (((active0 &= old0)) == 0L)
2809       return jjStartNfa_2(0, old0);
2810    try { curChar = input_stream.readChar(); }
2811    catch(java.io.IOException e) {
2812       jjStopStringLiteralDfa_2(1, active0);
2813       return 2;
2814    }
2815    switch(curChar)
2816    {
2817       case 91:
2818          if ((active0 & 0x40000L) != 0L)
2819             return jjStopAtPos(2, 18);
2820          break;
2821       case 76:
2822       case 108:
2823          return jjMoveStringLiteralDfa3_2(active0, 0x800000000L);
2824       case 85:
2825       case 117:
2826          return jjMoveStringLiteralDfa3_2(active0, 0x400000000L);
2827       default :
2828          break;
2829    }
2830    return jjStartNfa_2(1, active0);
2831 }
2832 private int jjMoveStringLiteralDfa3_2(long old0, long active0)
2833 {
2834    if (((active0 &= old0)) == 0L)
2835       return jjStartNfa_2(1, old0);
2836    try { curChar = input_stream.readChar(); }
2837    catch(java.io.IOException e) {
2838       jjStopStringLiteralDfa_2(2, active0);
2839       return 3;
2840    }
2841    switch(curChar)
2842    {
2843       case 69:
2844       case 101:
2845          if ((active0 & 0x400000000L) != 0L)
2846             return jjStopAtPos(3, 34);
2847          break;
2848       case 83:
2849       case 115:
2850          return jjMoveStringLiteralDfa4_2(active0, 0x800000000L);
2851       default :
2852          break;
2853    }
2854    return jjStartNfa_2(2, active0);
2855 }
2856 private int jjMoveStringLiteralDfa4_2(long old0, long active0)
2857 {
2858    if (((active0 &= old0)) == 0L)
2859       return jjStartNfa_2(2, old0);
2860    try { curChar = input_stream.readChar(); }
2861    catch(java.io.IOException e) {
2862       jjStopStringLiteralDfa_2(3, active0);
2863       return 4;
2864    }
2865    switch(curChar)
2866    {
2867       case 69:
2868       case 101:
2869          if ((active0 & 0x800000000L) != 0L)
2870             return jjStopAtPos(4, 35);
2871          break;
2872       default :
2873          break;
2874    }
2875    return jjStartNfa_2(3, active0);
2876 }
2877 private int jjStartNfaWithStates_2(int pos, int kind, int state)
2878 {
2879    jjmatchedKind = kind;
2880    jjmatchedPos = pos;
2881    try { curChar = input_stream.readChar(); }
2882    catch(java.io.IOException e) { return pos + 1; }
2883    return jjMoveNfa_2(state, pos + 1);
2884 }
2885 private int jjMoveNfa_2(int startState, int curPos)
2886 {
2887    int startsAt = 0;
2888    jjnewStateCnt = 59;
2889    int i = 1;
2890    jjstateSet[0] = startState;
2891    int kind = 0x7fffffff;
2892    for (;;)
2893    {
2894       if (++jjround == 0x7fffffff)
2895          ReInitRounds();
2896       if (curChar < 64)
2897       {
2898          long l = 1L << curChar;
2899          do
2900          {
2901             switch(jjstateSet[--i])
2902             {
2903                case 3:
2904                   if ((0x3ff000000000000L & l) != 0L)
2905                   {
2906                      if (kind > 58)
2907                         kind = 58;
2908                      jjCheckNAddStates(123, 128);
2909                   }
2910                   else if ((0x100002600L & l) != 0L)
2911                   {
2912                      if (kind > 32)
2913                         kind = 32;
2914                      jjCheckNAdd(4);
2915                   }
2916                   else if (curChar == 45)
2917                      jjCheckNAddStates(129, 132);
2918                   else if (curChar == 36)
2919                   {
2920                      if (kind > 16)
2921                         kind = 16;
2922                      jjCheckNAddTwoStates(41, 42);
2923                   }
2924                   else if (curChar == 46)
2925                      jjCheckNAdd(32);
2926                   else if (curChar == 39)
2927                      jjCheckNAddStates(133, 136);
2928                   else if (curChar == 34)
2929                      jjCheckNAddStates(137, 140);
2930                   else if (curChar == 35)
2931                      jjstateSet[jjnewStateCnt++] = 2;
2932                   break;
2933                case 0:
2934                   if (curChar == 42)
2935                      jjstateSet[jjnewStateCnt++] = 1;
2936                   break;
2937                case 1:
2938                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
2939                      kind = 19;
2940                   break;
2941                case 2:
2942                   if (curChar == 42)
2943                      jjstateSet[jjnewStateCnt++] = 0;
2944                   break;
2945                case 4:
2946                   if ((0x100002600L & l) == 0L)
2947                      break;
2948                   if (kind > 32)
2949                      kind = 32;
2950                   jjCheckNAdd(4);
2951                   break;
2952                case 5:
2953                case 7:
2954                   if (curChar == 34)
2955                      jjCheckNAddStates(137, 140);
2956                   break;
2957                case 6:
2958                   if ((0xfffffffbffffffffL & l) != 0L)
2959                      jjCheckNAddStates(137, 140);
2960                   break;
2961                case 8:
2962                   if (curChar == 34)
2963                      jjstateSet[jjnewStateCnt++] = 7;
2964                   break;
2965                case 9:
2966                   if (curChar == 34 && kind > 33)
2967                      kind = 33;
2968                   break;
2969                case 12:
2970                   if ((0xff000000000000L & l) != 0L)
2971                      jjCheckNAddStates(141, 145);
2972                   break;
2973                case 13:
2974                   if ((0xff000000000000L & l) != 0L)
2975                      jjCheckNAddStates(137, 140);
2976                   break;
2977                case 14:
2978                   if ((0xf000000000000L & l) != 0L)
2979                      jjstateSet[jjnewStateCnt++] = 15;
2980                   break;
2981                case 15:
2982                   if ((0xff000000000000L & l) != 0L)
2983                      jjCheckNAdd(13);
2984                   break;
2985                case 17:
2986                   if ((0x3ff000000000000L & l) != 0L)
2987                      jjstateSet[jjnewStateCnt++] = 18;
2988                   break;
2989                case 18:
2990                   if ((0x3ff000000000000L & l) != 0L)
2991                      jjstateSet[jjnewStateCnt++] = 19;
2992                   break;
2993                case 19:
2994                   if ((0x3ff000000000000L & l) != 0L)
2995                      jjstateSet[jjnewStateCnt++] = 20;
2996                   break;
2997                case 20:
2998                   if ((0x3ff000000000000L & l) != 0L)
2999                      jjCheckNAddStates(137, 140);
3000                   break;
3001                case 21:
3002                   if (curChar == 32)
3003                      jjAddStates(146, 147);
3004                   break;
3005                case 22:
3006                   if (curChar == 10)
3007                      jjCheckNAddStates(137, 140);
3008                   break;
3009                case 23:
3010                case 25:
3011                   if (curChar == 39)
3012                      jjCheckNAddStates(133, 136);
3013                   break;
3014                case 24:
3015                   if ((0xffffff7fffffffffL & l) != 0L)
3016                      jjCheckNAddStates(133, 136);
3017                   break;
3018                case 26:
3019                   if (curChar == 39)
3020                      jjstateSet[jjnewStateCnt++] = 25;
3021                   break;
3022                case 28:
3023                   if (curChar == 32)
3024                      jjAddStates(148, 149);
3025                   break;
3026                case 29:
3027                   if (curChar == 10)
3028                      jjCheckNAddStates(133, 136);
3029                   break;
3030                case 30:
3031                   if (curChar == 39 && kind > 33)
3032                      kind = 33;
3033                   break;
3034                case 31:
3035                   if (curChar == 46)
3036                      jjCheckNAdd(32);
3037                   break;
3038                case 32:
3039                   if ((0x3ff000000000000L & l) == 0L)
3040                      break;
3041                   if (kind > 59)
3042                      kind = 59;
3043                   jjCheckNAddTwoStates(32, 33);
3044                   break;
3045                case 34:
3046                   if ((0x280000000000L & l) != 0L)
3047                      jjCheckNAdd(35);
3048                   break;
3049                case 35:
3050                   if ((0x3ff000000000000L & l) == 0L)
3051                      break;
3052                   if (kind > 59)
3053                      kind = 59;
3054                   jjCheckNAdd(35);
3055                   break;
3056                case 38:
3057                   if (curChar == 36 && kind > 16)
3058                      kind = 16;
3059                   break;
3060                case 40:
3061                   if (curChar == 36)
3062                      jjCheckNAddTwoStates(41, 42);
3063                   break;
3064                case 42:
3065                   if (curChar == 33 && kind > 17)
3066                      kind = 17;
3067                   break;
3068                case 43:
3069                   if (curChar != 36)
3070                      break;
3071                   if (kind > 16)
3072                      kind = 16;
3073                   jjCheckNAddTwoStates(41, 42);
3074                   break;
3075                case 44:
3076                   if (curChar == 45)
3077                      jjCheckNAddStates(129, 132);
3078                   break;
3079                case 45:
3080                   if ((0x3ff000000000000L & l) == 0L)
3081                      break;
3082                   if (kind > 58)
3083                      kind = 58;
3084                   jjCheckNAddTwoStates(45, 47);
3085                   break;
3086                case 46:
3087                   if (curChar == 46 && kind > 58)
3088                      kind = 58;
3089                   break;
3090                case 47:
3091                   if (curChar == 46)
3092                      jjstateSet[jjnewStateCnt++] = 46;
3093                   break;
3094                case 48:
3095                   if ((0x3ff000000000000L & l) != 0L)
3096                      jjCheckNAddTwoStates(48, 49);
3097                   break;
3098                case 49:
3099                   if (curChar != 46)
3100                      break;
3101                   if (kind > 59)
3102                      kind = 59;
3103                   jjCheckNAddTwoStates(50, 51);
3104                   break;
3105                case 50:
3106                   if ((0x3ff000000000000L & l) == 0L)
3107                      break;
3108                   if (kind > 59)
3109                      kind = 59;
3110                   jjCheckNAddTwoStates(50, 51);
3111                   break;
3112                case 52:
3113                   if ((0x280000000000L & l) != 0L)
3114                      jjCheckNAdd(53);
3115                   break;
3116                case 53:
3117                   if ((0x3ff000000000000L & l) == 0L)
3118                      break;
3119                   if (kind > 59)
3120                      kind = 59;
3121                   jjCheckNAdd(53);
3122                   break;
3123                case 54:
3124                   if ((0x3ff000000000000L & l) != 0L)
3125                      jjCheckNAddTwoStates(54, 55);
3126                   break;
3127                case 56:
3128                   if ((0x280000000000L & l) != 0L)
3129                      jjCheckNAdd(57);
3130                   break;
3131                case 57:
3132                   if ((0x3ff000000000000L & l) == 0L)
3133                      break;
3134                   if (kind > 59)
3135                      kind = 59;
3136                   jjCheckNAdd(57);
3137                   break;
3138                case 58:
3139                   if ((0x3ff000000000000L & l) == 0L)
3140                      break;
3141                   if (kind > 58)
3142                      kind = 58;
3143                   jjCheckNAddStates(123, 128);
3144                   break;
3145                default : break;
3146             }
3147          } while(i != startsAt);
3148       }
3149       else if (curChar < 128)
3150       {
3151          long l = 1L << (curChar & 077);
3152          do
3153          {
3154             switch(jjstateSet[--i])
3155             {
3156                case 3:
3157                   if (curChar == 92)
3158                      jjCheckNAddStates(150, 153);
3159                   break;
3160                case 1:
3161                   if (kind > 19)
3162                      kind = 19;
3163                   break;
3164                case 6:
3165                   jjCheckNAddStates(137, 140);
3166                   break;
3167                case 10:
3168                   if (curChar == 92)
3169                      jjAddStates(154, 159);
3170                   break;
3171                case 11:
3172                   if ((0x14404400144044L & l) != 0L)
3173                      jjCheckNAddStates(137, 140);
3174                   break;
3175                case 16:
3176                   if ((0x20000000200000L & l) != 0L)
3177                      jjstateSet[jjnewStateCnt++] = 17;
3178                   break;
3179                case 17:
3180                   if ((0x7e0000007eL & l) != 0L)
3181                      jjstateSet[jjnewStateCnt++] = 18;
3182                   break;
3183                case 18:
3184                   if ((0x7e0000007eL & l) != 0L)
3185                      jjstateSet[jjnewStateCnt++] = 19;
3186                   break;
3187                case 19:
3188                   if ((0x7e0000007eL & l) != 0L)
3189                      jjstateSet[jjnewStateCnt++] = 20;
3190                   break;
3191                case 20:
3192                   if ((0x7e0000007eL & l) != 0L)
3193                      jjCheckNAddStates(137, 140);
3194                   break;
3195                case 24:
3196                   jjAddStates(133, 136);
3197                   break;
3198                case 27:
3199                   if (curChar == 92)
3200                      jjAddStates(148, 149);
3201                   break;
3202                case 33:
3203                   if ((0x2000000020L & l) != 0L)
3204                      jjAddStates(160, 161);
3205                   break;
3206                case 37:
3207                   if (curChar == 92)
3208                      jjCheckNAddTwoStates(37, 38);
3209                   break;
3210                case 39:
3211                   if (curChar == 92)
3212                      jjCheckNAddTwoStates(39, 40);
3213                   break;
3214                case 41:
3215                   if (curChar == 92)
3216                      jjAddStates(162, 163);
3217                   break;
3218                case 51:
3219                   if ((0x2000000020L & l) != 0L)
3220                      jjAddStates(164, 165);
3221                   break;
3222                case 55:
3223                   if ((0x2000000020L & l) != 0L)
3224                      jjAddStates(166, 167);
3225                   break;
3226                default : break;
3227             }
3228          } while(i != startsAt);
3229       }
3230       else
3231       {
3232          int hiByte = (int)(curChar >> 8);
3233          int i1 = hiByte >> 6;
3234          long l1 = 1L << (hiByte & 077);
3235          int i2 = (curChar & 0xff) >> 6;
3236          long l2 = 1L << (curChar & 077);
3237          do
3238          {
3239             switch(jjstateSet[--i])
3240             {
3241                case 1:
3242                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
3243                      kind = 19;
3244                   break;
3245                case 6:
3246                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3247                      jjAddStates(137, 140);
3248                   break;
3249                case 24:
3250                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3251                      jjAddStates(133, 136);
3252                   break;
3253                default : break;
3254             }
3255          } while(i != startsAt);
3256       }
3257       if (kind != 0x7fffffff)
3258       {
3259          jjmatchedKind = kind;
3260          jjmatchedPos = curPos;
3261          kind = 0x7fffffff;
3262       }
3263       ++curPos;
3264       if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt)))
3265          return curPos;
3266       try { curChar = input_stream.readChar(); }
3267       catch(java.io.IOException e) { return curPos; }
3268    }
3269 }
3270 private final int jjStopStringLiteralDfa_10(int pos, long active0)
3271 {
3272    switch (pos)
3273    {
3274       case 0:
3275          if ((active0 & 0x340000L) != 0L)
3276             return 2;
3277          return -1;
3278       case 1:
3279          if ((active0 & 0x100000L) != 0L)
3280             return 0;
3281          return -1;
3282       default :
3283          return -1;
3284    }
3285 }
3286 private final int jjStartNfa_10(int pos, long active0)
3287 {
3288    return jjMoveNfa_10(jjStopStringLiteralDfa_10(pos, active0), pos + 1);
3289 }
3290 private int jjMoveStringLiteralDfa0_10()
3291 {
3292    switch(curChar)
3293    {
3294       case 35:
3295          jjmatchedKind = 21;
3296          return jjMoveStringLiteralDfa1_10(0x140000L);
3297       default :
3298          return jjMoveNfa_10(3, 0);
3299    }
3300 }
3301 private int jjMoveStringLiteralDfa1_10(long active0)
3302 {
3303    try { curChar = input_stream.readChar(); }
3304    catch(java.io.IOException e) {
3305       jjStopStringLiteralDfa_10(0, active0);
3306       return 1;
3307    }
3308    switch(curChar)
3309    {
3310       case 42:
3311          if ((active0 & 0x100000L) != 0L)
3312             return jjStartNfaWithStates_10(1, 20, 0);
3313          break;
3314       case 91:
3315          return jjMoveStringLiteralDfa2_10(active0, 0x40000L);
3316       default :
3317          break;
3318    }
3319    return jjStartNfa_10(0, active0);
3320 }
3321 private int jjMoveStringLiteralDfa2_10(long old0, long active0)
3322 {
3323    if (((active0 &= old0)) == 0L)
3324       return jjStartNfa_10(0, old0);
3325    try { curChar = input_stream.readChar(); }
3326    catch(java.io.IOException e) {
3327       jjStopStringLiteralDfa_10(1, active0);
3328       return 2;
3329    }
3330    switch(curChar)
3331    {
3332       case 91:
3333          if ((active0 & 0x40000L) != 0L)
3334             return jjStopAtPos(2, 18);
3335          break;
3336       default :
3337          break;
3338    }
3339    return jjStartNfa_10(1, active0);
3340 }
3341 private int jjStartNfaWithStates_10(int pos, int kind, int state)
3342 {
3343    jjmatchedKind = kind;
3344    jjmatchedPos = pos;
3345    try { curChar = input_stream.readChar(); }
3346    catch(java.io.IOException e) { return pos + 1; }
3347    return jjMoveNfa_10(state, pos + 1);
3348 }
3349 private int jjMoveNfa_10(int startState, int curPos)
3350 {
3351    int startsAt = 0;
3352    jjnewStateCnt = 15;
3353    int i = 1;
3354    jjstateSet[0] = startState;
3355    int kind = 0x7fffffff;
3356    for (;;)
3357    {
3358       if (++jjround == 0x7fffffff)
3359          ReInitRounds();
3360       if (curChar < 64)
3361       {
3362          long l = 1L << curChar;
3363          do
3364          {
3365             switch(jjstateSet[--i])
3366             {
3367                case 3:
3368                   if ((0x2400L & l) != 0L)
3369                   {
3370                      if (kind > 26)
3371                         kind = 26;
3372                   }
3373                   else if (curChar == 36)
3374                   {
3375                      if (kind > 16)
3376                         kind = 16;
3377                      jjCheckNAddTwoStates(12, 13);
3378                   }
3379                   else if (curChar == 35)
3380                      jjstateSet[jjnewStateCnt++] = 2;
3381                   if (curChar == 13)
3382                      jjstateSet[jjnewStateCnt++] = 5;
3383                   break;
3384                case 0:
3385                   if (curChar == 42)
3386                      jjstateSet[jjnewStateCnt++] = 1;
3387                   break;
3388                case 1:
3389                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
3390                      kind = 19;
3391                   break;
3392                case 2:
3393                   if (curChar == 42)
3394                      jjstateSet[jjnewStateCnt++] = 0;
3395                   break;
3396                case 4:
3397                   if ((0x2400L & l) != 0L && kind > 26)
3398                      kind = 26;
3399                   break;
3400                case 5:
3401                   if (curChar == 10 && kind > 26)
3402                      kind = 26;
3403                   break;
3404                case 6:
3405                   if (curChar == 13)
3406                      jjstateSet[jjnewStateCnt++] = 5;
3407                   break;
3408                case 9:
3409                   if (curChar == 36 && kind > 16)
3410                      kind = 16;
3411                   break;
3412                case 11:
3413                   if (curChar == 36)
3414                      jjCheckNAddTwoStates(12, 13);
3415                   break;
3416                case 13:
3417                   if (curChar == 33 && kind > 17)
3418                      kind = 17;
3419                   break;
3420                case 14:
3421                   if (curChar != 36)
3422                      break;
3423                   if (kind > 16)
3424                      kind = 16;
3425                   jjCheckNAddTwoStates(12, 13);
3426                   break;
3427                default : break;
3428             }
3429          } while(i != startsAt);
3430       }
3431       else if (curChar < 128)
3432       {
3433          long l = 1L << (curChar & 077);
3434          do
3435          {
3436             switch(jjstateSet[--i])
3437             {
3438                case 3:
3439                   if (curChar == 92)
3440                      jjCheckNAddStates(168, 171);
3441                   break;
3442                case 1:
3443                   if (kind > 19)
3444                      kind = 19;
3445                   break;
3446                case 8:
3447                   if (curChar == 92)
3448                      jjCheckNAddTwoStates(8, 9);
3449                   break;
3450                case 10:
3451                   if (curChar == 92)
3452                      jjCheckNAddTwoStates(10, 11);
3453                   break;
3454                case 12:
3455                   if (curChar == 92)
3456                      jjAddStates(172, 173);
3457                   break;
3458                default : break;
3459             }
3460          } while(i != startsAt);
3461       }
3462       else
3463       {
3464          int hiByte = (int)(curChar >> 8);
3465          int i1 = hiByte >> 6;
3466          long l1 = 1L << (hiByte & 077);
3467          int i2 = (curChar & 0xff) >> 6;
3468          long l2 = 1L << (curChar & 077);
3469          do
3470          {
3471             switch(jjstateSet[--i])
3472             {
3473                case 1:
3474                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
3475                      kind = 19;
3476                   break;
3477                default : break;
3478             }
3479          } while(i != startsAt);
3480       }
3481       if (kind != 0x7fffffff)
3482       {
3483          jjmatchedKind = kind;
3484          jjmatchedPos = curPos;
3485          kind = 0x7fffffff;
3486       }
3487       ++curPos;
3488       if ((i = jjnewStateCnt) == (startsAt = 15 - (jjnewStateCnt = startsAt)))
3489          return curPos;
3490       try { curChar = input_stream.readChar(); }
3491       catch(java.io.IOException e) { return curPos; }
3492    }
3493 }
3494 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
3495 {
3496    switch (pos)
3497    {
3498       case 0:
3499          if ((active0 & 0x740000L) != 0L)
3500             return 33;
3501          if ((active0 & 0xc00000000L) != 0L)
3502          {
3503             jjmatchedKind = 68;
3504             return 13;
3505          }
3506          return -1;
3507       case 1:
3508          if ((active0 & 0xc00000000L) != 0L)
3509          {
3510             jjmatchedKind = 68;
3511             jjmatchedPos = 1;
3512             return 13;
3513          }
3514          if ((active0 & 0x100000L) != 0L)
3515             return 31;
3516          return -1;
3517       case 2:
3518          if ((active0 & 0xc00000000L) != 0L)
3519          {
3520             jjmatchedKind = 68;
3521             jjmatchedPos = 2;
3522             return 13;
3523          }
3524          return -1;
3525       case 3:
3526          if ((active0 & 0x800000000L) != 0L)
3527          {
3528             jjmatchedKind = 68;
3529             jjmatchedPos = 3;
3530             return 13;
3531          }
3532          if ((active0 & 0x400000000L) != 0L)
3533             return 13;
3534          return -1;
3535       default :
3536          return -1;
3537    }
3538 }
3539 private final int jjStartNfa_0(int pos, long active0, long active1)
3540 {
3541    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
3542 }
3543 private int jjMoveStringLiteralDfa0_0()
3544 {
3545    switch(curChar)
3546    {
3547       case 35:
3548          jjmatchedKind = 21;
3549          return jjMoveStringLiteralDfa1_0(0x540000L);
3550       case 91:
3551          return jjStopAtPos(0, 1);
3552       case 70:
3553       case 102:
3554          return jjMoveStringLiteralDfa1_0(0x800000000L);
3555       case 84:
3556       case 116:
3557          return jjMoveStringLiteralDfa1_0(0x400000000L);
3558       case 123:
3559          return jjStopAtPos(0, 70);
3560       case 125:
3561          return jjStopAtPos(0, 71);
3562       default :
3563          return jjMoveNfa_0(12, 0);
3564    }
3565 }
3566 private int jjMoveStringLiteralDfa1_0(long active0)
3567 {
3568    try { curChar = input_stream.readChar(); }
3569    catch(java.io.IOException e) {
3570       jjStopStringLiteralDfa_0(0, active0, 0L);
3571       return 1;
3572    }
3573    switch(curChar)
3574    {
3575       case 35:
3576          if ((active0 & 0x400000L) != 0L)
3577             return jjStopAtPos(1, 22);
3578          break;
3579       case 42:
3580          if ((active0 & 0x100000L) != 0L)
3581             return jjStartNfaWithStates_0(1, 20, 31);
3582          break;
3583       case 91:
3584          return jjMoveStringLiteralDfa2_0(active0, 0x40000L);
3585       case 65:
3586       case 97:
3587          return jjMoveStringLiteralDfa2_0(active0, 0x800000000L);
3588       case 82:
3589       case 114:
3590          return jjMoveStringLiteralDfa2_0(active0, 0x400000000L);
3591       default :
3592          break;
3593    }
3594    return jjStartNfa_0(0, active0, 0L);
3595 }
3596 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
3597 {
3598    if (((active0 &= old0)) == 0L)
3599       return jjStartNfa_0(0, old0, 0L);
3600    try { curChar = input_stream.readChar(); }
3601    catch(java.io.IOException e) {
3602       jjStopStringLiteralDfa_0(1, active0, 0L);
3603       return 2;
3604    }
3605    switch(curChar)
3606    {
3607       case 91:
3608          if ((active0 & 0x40000L) != 0L)
3609             return jjStopAtPos(2, 18);
3610          break;
3611       case 76:
3612       case 108:
3613          return jjMoveStringLiteralDfa3_0(active0, 0x800000000L);
3614       case 85:
3615       case 117:
3616          return jjMoveStringLiteralDfa3_0(active0, 0x400000000L);
3617       default :
3618          break;
3619    }
3620    return jjStartNfa_0(1, active0, 0L);
3621 }
3622 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
3623 {
3624    if (((active0 &= old0)) == 0L)
3625       return jjStartNfa_0(1, old0, 0L);
3626    try { curChar = input_stream.readChar(); }
3627    catch(java.io.IOException e) {
3628       jjStopStringLiteralDfa_0(2, active0, 0L);
3629       return 3;
3630    }
3631    switch(curChar)
3632    {
3633       case 69:
3634       case 101:
3635          if ((active0 & 0x400000000L) != 0L)
3636             return jjStartNfaWithStates_0(3, 34, 13);
3637          break;
3638       case 83:
3639       case 115:
3640          return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
3641       default :
3642          break;
3643    }
3644    return jjStartNfa_0(2, active0, 0L);
3645 }
3646 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
3647 {
3648    if (((active0 &= old0)) == 0L)
3649       return jjStartNfa_0(2, old0, 0L);
3650    try { curChar = input_stream.readChar(); }
3651    catch(java.io.IOException e) {
3652       jjStopStringLiteralDfa_0(3, active0, 0L);
3653       return 4;
3654    }
3655    switch(curChar)
3656    {
3657       case 69:
3658       case 101:
3659          if ((active0 & 0x800000000L) != 0L)
3660             return jjStartNfaWithStates_0(4, 35, 13);
3661          break;
3662       default :
3663          break;
3664    }
3665    return jjStartNfa_0(3, active0, 0L);
3666 }
3667 private int jjStartNfaWithStates_0(int pos, int kind, int state)
3668 {
3669    jjmatchedKind = kind;
3670    jjmatchedPos = pos;
3671    try { curChar = input_stream.readChar(); }
3672    catch(java.io.IOException e) { return pos + 1; }
3673    return jjMoveNfa_0(state, pos + 1);
3674 }
3675 private int jjMoveNfa_0(int startState, int curPos)
3676 {
3677    int startsAt = 0;
3678    jjnewStateCnt = 34;
3679    int i = 1;
3680    jjstateSet[0] = startState;
3681    int kind = 0x7fffffff;
3682    for (;;)
3683    {
3684       if (++jjround == 0x7fffffff)
3685          ReInitRounds();
3686       if (curChar < 64)
3687       {
3688          long l = 1L << curChar;
3689          do
3690          {
3691             switch(jjstateSet[--i])
3692             {
3693                case 12:
3694                   if ((0x100000200L & l) != 0L)
3695                      jjCheckNAddTwoStates(0, 1);
3696                   else if (curChar == 35)
3697                      jjCheckNAddStates(174, 176);
3698                   else if (curChar == 36)
3699                   {
3700                      if (kind > 16)
3701                         kind = 16;
3702                      jjCheckNAddTwoStates(27, 28);
3703                   }
3704                   else if (curChar == 46)
3705                      jjstateSet[jjnewStateCnt++] = 15;
3706                   if (curChar == 36)
3707                      jjCheckNAddStates(177, 180);
3708                   break;
3709                case 33:
3710                   if (curChar == 42)
3711                      jjstateSet[jjnewStateCnt++] = 31;
3712                   break;
3713                case 0:
3714                   if ((0x100000200L & l) != 0L)
3715                      jjCheckNAddTwoStates(0, 1);
3716                   break;
3717                case 1:
3718                   if (curChar == 35)
3719                      jjCheckNAddTwoStates(6, 11);
3720                   break;
3721                case 3:
3722                   if (curChar == 32)
3723                      jjAddStates(115, 116);
3724                   break;
3725                case 4:
3726                   if (curChar == 40 && kind > 15)
3727                      kind = 15;
3728                   break;
3729                case 13:
3730                   if ((0x3ff200000000000L & l) == 0L)
3731                      break;
3732                   if (kind > 68)
3733                      kind = 68;
3734                   jjstateSet[jjnewStateCnt++] = 13;
3735                   break;
3736                case 14:
3737                   if (curChar == 46)
3738                      jjstateSet[jjnewStateCnt++] = 15;
3739                   break;
3740                case 16:
3741                   if (curChar == 36)
3742                      jjCheckNAddStates(177, 180);
3743                   break;
3744                case 18:
3745                case 19:
3746                   if (curChar == 33)
3747                      jjCheckNAdd(17);
3748                   break;
3749                case 21:
3750                   if (curChar == 46 && kind > 74)
3751                      kind = 74;
3752                   break;
3753                case 24:
3754                   if (curChar == 36 && kind > 16)
3755                      kind = 16;
3756                   break;
3757                case 26:
3758                   if (curChar == 36)
3759                      jjCheckNAddTwoStates(27, 28);
3760                   break;
3761                case 28:
3762                   if (curChar == 33 && kind > 17)
3763                      kind = 17;
3764                   break;
3765                case 29:
3766                   if (curChar != 36)
3767                      break;
3768                   if (kind > 16)
3769                      kind = 16;
3770                   jjCheckNAddTwoStates(27, 28);
3771                   break;
3772                case 30:
3773                   if (curChar == 35)
3774                      jjCheckNAddStates(174, 176);
3775                   break;
3776                case 31:
3777                   if (curChar == 42)
3778                      jjstateSet[jjnewStateCnt++] = 32;
3779                   break;
3780                case 32:
3781                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
3782                      kind = 19;
3783                   break;
3784                default : break;
3785             }
3786          } while(i != startsAt);
3787       }
3788       else if (curChar < 128)
3789       {
3790          long l = 1L << (curChar & 077);
3791          do
3792          {
3793             switch(jjstateSet[--i])
3794             {
3795                case 12:
3796                   if ((0x7fffffe87fffffeL & l) != 0L)
3797                   {
3798                      if (kind > 68)
3799                         kind = 68;
3800                      jjCheckNAdd(13);
3801                   }
3802                   else if (curChar == 92)
3803                      jjCheckNAddStates(181, 184);
3804                   break;
3805                case 33:
3806                   if ((0x8000000080000L & l) != 0L)
3807                      jjstateSet[jjnewStateCnt++] = 5;
3808                   else if (curChar == 123)
3809                      jjstateSet[jjnewStateCnt++] = 10;
3810                   break;
3811                case 2:
3812                   if ((0x10000000100000L & l) != 0L)
3813                      jjCheckNAddTwoStates(3, 4);
3814                   break;
3815                case 5:
3816                   if ((0x2000000020L & l) != 0L)
3817                      jjstateSet[jjnewStateCnt++] = 2;
3818                   break;
3819                case 6:
3820                   if ((0x8000000080000L & l) != 0L)
3821                      jjstateSet[jjnewStateCnt++] = 5;
3822                   break;
3823                case 7:
3824                   if (curChar == 125)
3825                      jjCheckNAddTwoStates(3, 4);
3826                   break;
3827                case 8:
3828                   if ((0x10000000100000L & l) != 0L)
3829                      jjstateSet[jjnewStateCnt++] = 7;
3830                   break;
3831                case 9:
3832                   if ((0x2000000020L & l) != 0L)
3833                      jjstateSet[jjnewStateCnt++] = 8;
3834                   break;
3835                case 10:
3836                   if ((0x8000000080000L & l) != 0L)
3837                      jjstateSet[jjnewStateCnt++] = 9;
3838                   break;
3839                case 11:
3840                   if (curChar == 123)
3841                      jjstateSet[jjnewStateCnt++] = 10;
3842                   break;
3843                case 13:
3844                   if ((0x7fffffe87fffffeL & l) == 0L)
3845                      break;
3846                   if (kind > 68)
3847                      kind = 68;
3848                   jjCheckNAdd(13);
3849                   break;
3850                case 15:
3851                   if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
3852                      kind = 69;
3853                   break;
3854                case 17:
3855                   if (curChar == 91 && kind > 74)
3856                      kind = 74;
3857                   break;
3858                case 20:
3859                   if (curChar == 92)
3860                      jjstateSet[jjnewStateCnt++] = 19;
3861                   break;
3862                case 22:
3863                   if (curChar == 92)
3864                      jjCheckNAddStates(181, 184);
3865                   break;
3866                case 23:
3867                   if (curChar == 92)
3868                      jjCheckNAddTwoStates(23, 24);
3869                   break;
3870                case 25:
3871                   if (curChar == 92)
3872                      jjCheckNAddTwoStates(25, 26);
3873                   break;
3874                case 27:
3875                   if (curChar == 92)
3876                      jjAddStates(185, 186);
3877                   break;
3878                case 32:
3879                   if (kind > 19)
3880                      kind = 19;
3881                   break;
3882                default : break;
3883             }
3884          } while(i != startsAt);
3885       }
3886       else
3887       {
3888          int hiByte = (int)(curChar >> 8);
3889          int i1 = hiByte >> 6;
3890          long l1 = 1L << (hiByte & 077);
3891          int i2 = (curChar & 0xff) >> 6;
3892          long l2 = 1L << (curChar & 077);
3893          do
3894          {
3895             switch(jjstateSet[--i])
3896             {
3897                case 32:
3898                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
3899                      kind = 19;
3900                   break;
3901                default : break;
3902             }
3903          } while(i != startsAt);
3904       }
3905       if (kind != 0x7fffffff)
3906       {
3907          jjmatchedKind = kind;
3908          jjmatchedPos = curPos;
3909          kind = 0x7fffffff;
3910       }
3911       ++curPos;
3912       if ((i = jjnewStateCnt) == (startsAt = 34 - (jjnewStateCnt = startsAt)))
3913          return curPos;
3914       try { curChar = input_stream.readChar(); }
3915       catch(java.io.IOException e) { return curPos; }
3916    }
3917 }
3918 private final int jjStopStringLiteralDfa_4(int pos, long active0)
3919 {
3920    switch (pos)
3921    {
3922       case 0:
3923          if ((active0 & 0x340000L) != 0L)
3924             return 52;
3925          if ((active0 & 0x40L) != 0L)
3926             return 74;
3927          if ((active0 & 0xc00000080L) != 0L)
3928          {
3929             jjmatchedKind = 68;
3930             return 40;
3931          }
3932          return -1;
3933       case 1:
3934          if ((active0 & 0xc00000000L) != 0L)
3935          {
3936             jjmatchedKind = 68;
3937             jjmatchedPos = 1;
3938             return 40;
3939          }
3940          if ((active0 & 0x100000L) != 0L)
3941             return 50;
3942          if ((active0 & 0x80L) != 0L)
3943             return 40;
3944          return -1;
3945       case 2:
3946          if ((active0 & 0xc00000000L) != 0L)
3947          {
3948             jjmatchedKind = 68;
3949             jjmatchedPos = 2;
3950             return 40;
3951          }
3952          return -1;
3953       case 3:
3954          if ((active0 & 0x800000000L) != 0L)
3955          {
3956             jjmatchedKind = 68;
3957             jjmatchedPos = 3;
3958             return 40;
3959          }
3960          if ((active0 & 0x400000000L) != 0L)
3961             return 40;
3962          return -1;
3963       default :
3964          return -1;
3965    }
3966 }
3967 private final int jjStartNfa_4(int pos, long active0)
3968 {
3969    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
3970 }
3971 private int jjMoveStringLiteralDfa0_4()
3972 {
3973    switch(curChar)
3974    {
3975       case 35:
3976          jjmatchedKind = 21;
3977          return jjMoveStringLiteralDfa1_4(0x140000L);
3978       case 41:
3979          return jjStopAtPos(0, 13);
3980       case 44:
3981          return jjStopAtPos(0, 5);
3982       case 46:
3983          return jjMoveStringLiteralDfa1_4(0x40L);
3984       case 58:
3985          return jjStopAtPos(0, 8);
3986       case 91:
3987          return jjStopAtPos(0, 3);
3988       case 93:
3989          return jjStopAtPos(0, 4);
3990       case 70:
3991       case 102:
3992          return jjMoveStringLiteralDfa1_4(0x800000000L);
3993       case 73:
3994       case 105:
3995          return jjMoveStringLiteralDfa1_4(0x80L);
3996       case 84:
3997       case 116:
3998          return jjMoveStringLiteralDfa1_4(0x400000000L);
3999       case 123:
4000          return jjStopAtPos(0, 9);
4001       case 125:
4002          return jjStopAtPos(0, 10);
4003       default :
4004          return jjMoveNfa_4(13, 0);
4005    }
4006 }
4007 private int jjMoveStringLiteralDfa1_4(long active0)
4008 {
4009    try { curChar = input_stream.readChar(); }
4010    catch(java.io.IOException e) {
4011       jjStopStringLiteralDfa_4(0, active0);
4012       return 1;
4013    }
4014    switch(curChar)
4015    {
4016       case 42:
4017          if ((active0 & 0x100000L) != 0L)
4018             return jjStartNfaWithStates_4(1, 20, 50);
4019          break;
4020       case 46:
4021          if ((active0 & 0x40L) != 0L)
4022             return jjStopAtPos(1, 6);
4023          break;
4024       case 91:
4025          return jjMoveStringLiteralDfa2_4(active0, 0x40000L);
4026       case 65:
4027       case 97:
4028          return jjMoveStringLiteralDfa2_4(active0, 0x800000000L);
4029       case 78:
4030       case 110:
4031          if ((active0 & 0x80L) != 0L)
4032             return jjStartNfaWithStates_4(1, 7, 40);
4033          break;
4034       case 82:
4035       case 114:
4036          return jjMoveStringLiteralDfa2_4(active0, 0x400000000L);
4037       default :
4038          break;
4039    }
4040    return jjStartNfa_4(0, active0);
4041 }
4042 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
4043 {
4044    if (((active0 &= old0)) == 0L)
4045       return jjStartNfa_4(0, old0);
4046    try { curChar = input_stream.readChar(); }
4047    catch(java.io.IOException e) {
4048       jjStopStringLiteralDfa_4(1, active0);
4049       return 2;
4050    }
4051    switch(curChar)
4052    {
4053       case 91:
4054          if ((active0 & 0x40000L) != 0L)
4055             return jjStopAtPos(2, 18);
4056          break;
4057       case 76:
4058       case 108:
4059          return jjMoveStringLiteralDfa3_4(active0, 0x800000000L);
4060       case 85:
4061       case 117:
4062          return jjMoveStringLiteralDfa3_4(active0, 0x400000000L);
4063       default :
4064          break;
4065    }
4066    return jjStartNfa_4(1, active0);
4067 }
4068 private int jjMoveStringLiteralDfa3_4(long old0, long active0)
4069 {
4070    if (((active0 &= old0)) == 0L)
4071       return jjStartNfa_4(1, old0);
4072    try { curChar = input_stream.readChar(); }
4073    catch(java.io.IOException e) {
4074       jjStopStringLiteralDfa_4(2, active0);
4075       return 3;
4076    }
4077    switch(curChar)
4078    {
4079       case 69:
4080       case 101:
4081          if ((active0 & 0x400000000L) != 0L)
4082             return jjStartNfaWithStates_4(3, 34, 40);
4083          break;
4084       case 83:
4085       case 115:
4086          return jjMoveStringLiteralDfa4_4(active0, 0x800000000L);
4087       default :
4088          break;
4089    }
4090    return jjStartNfa_4(2, active0);
4091 }
4092 private int jjMoveStringLiteralDfa4_4(long old0, long active0)
4093 {
4094    if (((active0 &= old0)) == 0L)
4095       return jjStartNfa_4(2, old0);
4096    try { curChar = input_stream.readChar(); }
4097    catch(java.io.IOException e) {
4098       jjStopStringLiteralDfa_4(3, active0);
4099       return 4;
4100    }
4101    switch(curChar)
4102    {
4103       case 69:
4104       case 101:
4105          if ((active0 & 0x800000000L) != 0L)
4106             return jjStartNfaWithStates_4(4, 35, 40);
4107          break;
4108       default :
4109          break;
4110    }
4111    return jjStartNfa_4(3, active0);
4112 }
4113 private int jjStartNfaWithStates_4(int pos, int kind, int state)
4114 {
4115    jjmatchedKind = kind;
4116    jjmatchedPos = pos;
4117    try { curChar = input_stream.readChar(); }
4118    catch(java.io.IOException e) { return pos + 1; }
4119    return jjMoveNfa_4(state, pos + 1);
4120 }
4121 private int jjMoveNfa_4(int startState, int curPos)
4122 {
4123    int startsAt = 0;
4124    jjnewStateCnt = 75;
4125    int i = 1;
4126    jjstateSet[0] = startState;
4127    int kind = 0x7fffffff;
4128    for (;;)
4129    {
4130       if (++jjround == 0x7fffffff)
4131          ReInitRounds();
4132       if (curChar < 64)
4133       {
4134          long l = 1L << curChar;
4135          do
4136          {
4137             switch(jjstateSet[--i])
4138             {
4139                case 52:
4140                   if (curChar == 42)
4141                      jjstateSet[jjnewStateCnt++] = 50;
4142                   break;
4143                case 74:
4144                case 64:
4145                   if ((0x3ff000000000000L & l) == 0L)
4146                      break;
4147                   if (kind > 59)
4148                      kind = 59;
4149                   jjCheckNAddTwoStates(64, 65);
4150                   break;
4151                case 13:
4152                   if ((0x3ff000000000000L & l) != 0L)
4153                   {
4154                      if (kind > 58)
4155                         kind = 58;
4156                      jjCheckNAddStates(187, 192);
4157                   }
4158                   else if ((0x100002600L & l) != 0L)
4159                   {
4160                      if (kind > 32)
4161                         kind = 32;
4162                      jjCheckNAdd(12);
4163                   }
4164                   else if (curChar == 46)
4165                      jjCheckNAddTwoStates(64, 74);
4166                   else if (curChar == 45)
4167                      jjCheckNAddStates(193, 196);
4168                   else if (curChar == 35)
4169                      jjCheckNAddStates(197, 199);
4170                   else if (curChar == 36)
4171                   {
4172                      if (kind > 16)
4173                         kind = 16;
4174                      jjCheckNAddTwoStates(46, 47);
4175                   }
4176                   else if (curChar == 39)
4177                      jjCheckNAddStates(200, 203);
4178                   else if (curChar == 34)
4179                      jjCheckNAddStates(204, 207);
4180                   if ((0x100000200L & l) != 0L)
4181                      jjCheckNAddTwoStates(0, 1);
4182                   break;
4183                case 0:
4184                   if ((0x100000200L & l) != 0L)
4185                      jjCheckNAddTwoStates(0, 1);
4186                   break;
4187                case 1:
4188                   if (curChar == 35)
4189                      jjCheckNAddTwoStates(6, 11);
4190                   break;
4191                case 3:
4192                   if (curChar == 32)
4193                      jjAddStates(115, 116);
4194                   break;
4195                case 4:
4196                   if (curChar == 40 && kind > 15)
4197                      kind = 15;
4198                   break;
4199                case 12:
4200                   if ((0x100002600L & l) == 0L)
4201                      break;
4202                   if (kind > 32)
4203                      kind = 32;
4204                   jjCheckNAdd(12);
4205                   break;
4206                case 14:
4207                   if ((0xfffffffbffffffffL & l) != 0L)
4208                      jjCheckNAddStates(204, 207);
4209                   break;
4210                case 15:
4211                   if (curChar == 34)
4212                      jjCheckNAddStates(204, 207);
4213                   break;
4214                case 16:
4215                   if (curChar == 34)
4216                      jjstateSet[jjnewStateCnt++] = 15;
4217                   break;
4218                case 17:
4219                   if (curChar == 34 && kind > 33)
4220                      kind = 33;
4221                   break;
4222                case 20:
4223                   if ((0xff000000000000L & l) != 0L)
4224                      jjCheckNAddStates(208, 212);
4225                   break;
4226                case 21:
4227                   if ((0xff000000000000L & l) != 0L)
4228                      jjCheckNAddStates(204, 207);
4229                   break;
4230                case 22:
4231                   if ((0xf000000000000L & l) != 0L)
4232                      jjstateSet[jjnewStateCnt++] = 23;
4233                   break;
4234                case 23:
4235                   if ((0xff000000000000L & l) != 0L)
4236                      jjCheckNAdd(21);
4237                   break;
4238                case 25:
4239                   if ((0x3ff000000000000L & l) != 0L)
4240                      jjstateSet[jjnewStateCnt++] = 26;
4241                   break;
4242                case 26:
4243                   if ((0x3ff000000000000L & l) != 0L)
4244                      jjstateSet[jjnewStateCnt++] = 27;
4245                   break;
4246                case 27:
4247                   if ((0x3ff000000000000L & l) != 0L)
4248                      jjstateSet[jjnewStateCnt++] = 28;
4249                   break;
4250                case 28:
4251                   if ((0x3ff000000000000L & l) != 0L)
4252                      jjCheckNAddStates(204, 207);
4253                   break;
4254                case 29:
4255                   if (curChar == 32)
4256                      jjAddStates(94, 95);
4257                   break;
4258                case 30:
4259                   if (curChar == 10)
4260                      jjCheckNAddStates(204, 207);
4261                   break;
4262                case 31:
4263                case 33:
4264                   if (curChar == 39)
4265                      jjCheckNAddStates(200, 203);
4266                   break;
4267                case 32:
4268                   if ((0xffffff7fffffffffL & l) != 0L)
4269                      jjCheckNAddStates(200, 203);
4270                   break;
4271                case 34:
4272                   if (curChar == 39)
4273                      jjstateSet[jjnewStateCnt++] = 33;
4274                   break;
4275                case 36:
4276                   if (curChar == 32)
4277                      jjAddStates(213, 214);
4278                   break;
4279                case 37:
4280                   if (curChar == 10)
4281                      jjCheckNAddStates(200, 203);
4282                   break;
4283                case 38:
4284                   if (curChar == 39 && kind > 33)
4285                      kind = 33;
4286                   break;
4287                case 40:
4288                   if ((0x3ff200000000000L & l) == 0L)
4289                      break;
4290                   if (kind > 68)
4291                      kind = 68;
4292                   jjstateSet[jjnewStateCnt++] = 40;
4293                   break;
4294                case 43:
4295                   if (curChar == 36 && kind > 16)
4296                      kind = 16;
4297                   break;
4298                case 45:
4299                   if (curChar == 36)
4300                      jjCheckNAddTwoStates(46, 47);
4301                   break;
4302                case 47:
4303                   if (curChar == 33 && kind > 17)
4304                      kind = 17;
4305                   break;
4306                case 48:
4307                   if (curChar != 36)
4308                      break;
4309                   if (kind > 16)
4310                      kind = 16;
4311                   jjCheckNAddTwoStates(46, 47);
4312                   break;
4313                case 49:
4314                   if (curChar == 35)
4315                      jjCheckNAddStates(197, 199);
4316                   break;
4317                case 50:
4318                   if (curChar == 42)
4319                      jjstateSet[jjnewStateCnt++] = 51;
4320                   break;
4321                case 51:
4322                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
4323                      kind = 19;
4324                   break;
4325                case 53:
4326                   if (curChar == 45)
4327                      jjCheckNAddStates(193, 196);
4328                   break;
4329                case 54:
4330                   if ((0x3ff000000000000L & l) == 0L)
4331                      break;
4332                   if (kind > 58)
4333                      kind = 58;
4334                   jjCheckNAddTwoStates(54, 56);
4335                   break;
4336                case 55:
4337                   if (curChar == 46 && kind > 58)
4338                      kind = 58;
4339                   break;
4340                case 56:
4341                   if (curChar == 46)
4342                      jjstateSet[jjnewStateCnt++] = 55;
4343                   break;
4344                case 57:
4345                   if ((0x3ff000000000000L & l) != 0L)
4346                      jjCheckNAddTwoStates(57, 58);
4347                   break;
4348                case 58:
4349                   if (curChar != 46)
4350                      break;
4351                   if (kind > 59)
4352                      kind = 59;
4353                   jjCheckNAddTwoStates(59, 60);
4354                   break;
4355                case 59:
4356                   if ((0x3ff000000000000L & l) == 0L)
4357                      break;
4358                   if (kind > 59)
4359                      kind = 59;
4360                   jjCheckNAddTwoStates(59, 60);
4361                   break;
4362                case 61:
4363                   if ((0x280000000000L & l) != 0L)
4364                      jjCheckNAdd(62);
4365                   break;
4366                case 62:
4367                   if ((0x3ff000000000000L & l) == 0L)
4368                      break;
4369                   if (kind > 59)
4370                      kind = 59;
4371                   jjCheckNAdd(62);
4372                   break;
4373                case 63:
4374                   if (curChar == 46)
4375                      jjCheckNAdd(64);
4376                   break;
4377                case 66:
4378                   if ((0x280000000000L & l) != 0L)
4379                      jjCheckNAdd(67);
4380                   break;
4381                case 67:
4382                   if ((0x3ff000000000000L & l) == 0L)
4383                      break;
4384                   if (kind > 59)
4385                      kind = 59;
4386                   jjCheckNAdd(67);
4387                   break;
4388                case 68:
4389                   if ((0x3ff000000000000L & l) != 0L)
4390                      jjCheckNAddTwoStates(68, 69);
4391                   break;
4392                case 70:
4393                   if ((0x280000000000L & l) != 0L)
4394                      jjCheckNAdd(71);
4395                   break;
4396                case 71:
4397                   if ((0x3ff000000000000L & l) == 0L)
4398                      break;
4399                   if (kind > 59)
4400                      kind = 59;
4401                   jjCheckNAdd(71);
4402                   break;
4403                case 72:
4404                   if ((0x3ff000000000000L & l) == 0L)
4405                      break;
4406                   if (kind > 58)
4407                      kind = 58;
4408                   jjCheckNAddStates(187, 192);
4409                   break;
4410                case 73:
4411                   if (curChar == 46)
4412                      jjCheckNAddTwoStates(64, 74);
4413                   break;
4414                default : break;
4415             }
4416          } while(i != startsAt);
4417       }
4418       else if (curChar < 128)
4419       {
4420          long l = 1L << (curChar & 077);
4421          do
4422          {
4423             switch(jjstateSet[--i])
4424             {
4425                case 52:
4426                   if ((0x8000000080000L & l) != 0L)
4427                      jjstateSet[jjnewStateCnt++] = 5;
4428                   else if (curChar == 123)
4429                      jjstateSet[jjnewStateCnt++] = 10;
4430                   break;
4431                case 74:
4432                   if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
4433                      kind = 69;
4434                   break;
4435                case 13:
4436                   if ((0x7fffffe87fffffeL & l) != 0L)
4437                   {
4438                      if (kind > 68)
4439                         kind = 68;
4440                      jjCheckNAdd(40);
4441                   }
4442                   else if (curChar == 92)
4443                      jjCheckNAddStates(215, 218);
4444                   break;
4445                case 2:
4446                   if ((0x10000000100000L & l) != 0L)
4447                      jjCheckNAddTwoStates(3, 4);
4448                   break;
4449                case 5:
4450                   if ((0x2000000020L & l) != 0L)
4451                      jjstateSet[jjnewStateCnt++] = 2;
4452                   break;
4453                case 6:
4454                   if ((0x8000000080000L & l) != 0L)
4455                      jjstateSet[jjnewStateCnt++] = 5;
4456                   break;
4457                case 7:
4458                   if (curChar == 125)
4459                      jjCheckNAddTwoStates(3, 4);
4460                   break;
4461                case 8:
4462                   if ((0x10000000100000L & l) != 0L)
4463                      jjstateSet[jjnewStateCnt++] = 7;
4464                   break;
4465                case 9:
4466                   if ((0x2000000020L & l) != 0L)
4467                      jjstateSet[jjnewStateCnt++] = 8;
4468                   break;
4469                case 10:
4470                   if ((0x8000000080000L & l) != 0L)
4471                      jjstateSet[jjnewStateCnt++] = 9;
4472                   break;
4473                case 11:
4474                   if (curChar == 123)
4475                      jjstateSet[jjnewStateCnt++] = 10;
4476                   break;
4477                case 14:
4478                   jjCheckNAddStates(204, 207);
4479                   break;
4480                case 18:
4481                   if (curChar == 92)
4482                      jjAddStates(219, 224);
4483                   break;
4484                case 19:
4485                   if ((0x14404400144044L & l) != 0L)
4486                      jjCheckNAddStates(204, 207);
4487                   break;
4488                case 24:
4489                   if ((0x20000000200000L & l) != 0L)
4490                      jjstateSet[jjnewStateCnt++] = 25;
4491                   break;
4492                case 25:
4493                   if ((0x7e0000007eL & l) != 0L)
4494                      jjstateSet[jjnewStateCnt++] = 26;
4495                   break;
4496                case 26:
4497                   if ((0x7e0000007eL & l) != 0L)
4498                      jjstateSet[jjnewStateCnt++] = 27;
4499                   break;
4500                case 27:
4501                   if ((0x7e0000007eL & l) != 0L)
4502                      jjstateSet[jjnewStateCnt++] = 28;
4503                   break;
4504                case 28:
4505                   if ((0x7e0000007eL & l) != 0L)
4506                      jjCheckNAddStates(204, 207);
4507                   break;
4508                case 32:
4509                   jjAddStates(200, 203);
4510                   break;
4511                case 35:
4512                   if (curChar == 92)
4513                      jjAddStates(213, 214);
4514                   break;
4515                case 39:
4516                case 40:
4517                   if ((0x7fffffe87fffffeL & l) == 0L)
4518                      break;
4519                   if (kind > 68)
4520                      kind = 68;
4521                   jjCheckNAdd(40);
4522                   break;
4523                case 41:
4524                   if (curChar == 92)
4525                      jjCheckNAddStates(215, 218);
4526                   break;
4527                case 42:
4528                   if (curChar == 92)
4529                      jjCheckNAddTwoStates(42, 43);
4530                   break;
4531                case 44:
4532                   if (curChar == 92)
4533                      jjCheckNAddTwoStates(44, 45);
4534                   break;
4535                case 46:
4536                   if (curChar == 92)
4537                      jjAddStates(225, 226);
4538                   break;
4539                case 51:
4540                   if (kind > 19)
4541                      kind = 19;
4542                   break;
4543                case 60:
4544                   if ((0x2000000020L & l) != 0L)
4545                      jjAddStates(227, 228);
4546                   break;
4547                case 65:
4548                   if ((0x2000000020L & l) != 0L)
4549                      jjAddStates(229, 230);
4550                   break;
4551                case 69:
4552                   if ((0x2000000020L & l) != 0L)
4553                      jjAddStates(30, 31);
4554                   break;
4555                default : break;
4556             }
4557          } while(i != startsAt);
4558       }
4559       else
4560       {
4561          int hiByte = (int)(curChar >> 8);
4562          int i1 = hiByte >> 6;
4563          long l1 = 1L << (hiByte & 077);
4564          int i2 = (curChar & 0xff) >> 6;
4565          long l2 = 1L << (curChar & 077);
4566          do
4567          {
4568             switch(jjstateSet[--i])
4569             {
4570                case 14:
4571                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4572                      jjAddStates(204, 207);
4573                   break;
4574                case 32:
4575                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
4576                      jjAddStates(200, 203);
4577                   break;
4578                case 51:
4579                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
4580                      kind = 19;
4581                   break;
4582                default : break;
4583             }
4584          } while(i != startsAt);
4585       }
4586       if (kind != 0x7fffffff)
4587       {
4588          jjmatchedKind = kind;
4589          jjmatchedPos = curPos;
4590          kind = 0x7fffffff;
4591       }
4592       ++curPos;
4593       if ((i = jjnewStateCnt) == (startsAt = 75 - (jjnewStateCnt = startsAt)))
4594          return curPos;
4595       try { curChar = input_stream.readChar(); }
4596       catch(java.io.IOException e) { return curPos; }
4597    }
4598 }
4599 private final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
4600 {
4601    switch (pos)
4602    {
4603       case 0:
4604          if ((active0 & 0xc00000000L) != 0L)
4605          {
4606             jjmatchedKind = 68;
4607             return 13;
4608          }
4609          if ((active0 & 0x340000L) != 0L)
4610             return 27;
4611          return -1;
4612       case 1:
4613          if ((active0 & 0xc00000000L) != 0L)
4614          {
4615             jjmatchedKind = 68;
4616             jjmatchedPos = 1;
4617             return 13;
4618          }
4619          if ((active0 & 0x100000L) != 0L)
4620             return 25;
4621          return -1;
4622       case 2:
4623          if ((active0 & 0xc00000000L) != 0L)
4624          {
4625             jjmatchedKind = 68;
4626             jjmatchedPos = 2;
4627             return 13;
4628          }
4629          return -1;
4630       case 3:
4631          if ((active0 & 0x800000000L) != 0L)
4632          {
4633             jjmatchedKind = 68;
4634             jjmatchedPos = 3;
4635             return 13;
4636          }
4637          if ((active0 & 0x400000000L) != 0L)
4638             return 13;
4639          return -1;
4640       default :
4641          return -1;
4642    }
4643 }
4644 private final int jjStartNfa_1(int pos, long active0, long active1)
4645 {
4646    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
4647 }
4648 private int jjMoveStringLiteralDfa0_1()
4649 {
4650    switch(curChar)
4651    {
4652       case 35:
4653          jjmatchedKind = 21;
4654          return jjMoveStringLiteralDfa1_1(0x140000L);
4655       case 40:
4656          return jjStopAtPos(0, 11);
4657       case 91:
4658          return jjStopAtPos(0, 1);
4659       case 70:
4660       case 102:
4661          return jjMoveStringLiteralDfa1_1(0x800000000L);
4662       case 84:
4663       case 116:
4664          return jjMoveStringLiteralDfa1_1(0x400000000L);
4665       case 123:
4666          return jjStopAtPos(0, 70);
4667       case 125:
4668          return jjStopAtPos(0, 71);
4669       default :
4670          return jjMoveNfa_1(12, 0);
4671    }
4672 }
4673 private int jjMoveStringLiteralDfa1_1(long active0)
4674 {
4675    try { curChar = input_stream.readChar(); }
4676    catch(java.io.IOException e) {
4677       jjStopStringLiteralDfa_1(0, active0, 0L);
4678       return 1;
4679    }
4680    switch(curChar)
4681    {
4682       case 42:
4683          if ((active0 & 0x100000L) != 0L)
4684             return jjStartNfaWithStates_1(1, 20, 25);
4685          break;
4686       case 91:
4687          return jjMoveStringLiteralDfa2_1(active0, 0x40000L);
4688       case 65:
4689       case 97:
4690          return jjMoveStringLiteralDfa2_1(active0, 0x800000000L);
4691       case 82:
4692       case 114:
4693          return jjMoveStringLiteralDfa2_1(active0, 0x400000000L);
4694       default :
4695          break;
4696    }
4697    return jjStartNfa_1(0, active0, 0L);
4698 }
4699 private int jjMoveStringLiteralDfa2_1(long old0, long active0)
4700 {
4701    if (((active0 &= old0)) == 0L)
4702       return jjStartNfa_1(0, old0, 0L);
4703    try { curChar = input_stream.readChar(); }
4704    catch(java.io.IOException e) {
4705       jjStopStringLiteralDfa_1(1, active0, 0L);
4706       return 2;
4707    }
4708    switch(curChar)
4709    {
4710       case 91:
4711          if ((active0 & 0x40000L) != 0L)
4712             return jjStopAtPos(2, 18);
4713          break;
4714       case 76:
4715       case 108:
4716          return jjMoveStringLiteralDfa3_1(active0, 0x800000000L);
4717       case 85:
4718       case 117:
4719          return jjMoveStringLiteralDfa3_1(active0, 0x400000000L);
4720       default :
4721          break;
4722    }
4723    return jjStartNfa_1(1, active0, 0L);
4724 }
4725 private int jjMoveStringLiteralDfa3_1(long old0, long active0)
4726 {
4727    if (((active0 &= old0)) == 0L)
4728       return jjStartNfa_1(1, old0, 0L);
4729    try { curChar = input_stream.readChar(); }
4730    catch(java.io.IOException e) {
4731       jjStopStringLiteralDfa_1(2, active0, 0L);
4732       return 3;
4733    }
4734    switch(curChar)
4735    {
4736       case 69:
4737       case 101:
4738          if ((active0 & 0x400000000L) != 0L)
4739             return jjStartNfaWithStates_1(3, 34, 13);
4740          break;
4741       case 83:
4742       case 115:
4743          return jjMoveStringLiteralDfa4_1(active0, 0x800000000L);
4744       default :
4745          break;
4746    }
4747    return jjStartNfa_1(2, active0, 0L);
4748 }
4749 private int jjMoveStringLiteralDfa4_1(long old0, long active0)
4750 {
4751    if (((active0 &= old0)) == 0L)
4752       return jjStartNfa_1(2, old0, 0L);
4753    try { curChar = input_stream.readChar(); }
4754    catch(java.io.IOException e) {
4755       jjStopStringLiteralDfa_1(3, active0, 0L);
4756       return 4;
4757    }
4758    switch(curChar)
4759    {
4760       case 69:
4761       case 101:
4762          if ((active0 & 0x800000000L) != 0L)
4763             return jjStartNfaWithStates_1(4, 35, 13);
4764          break;
4765       default :
4766          break;
4767    }
4768    return jjStartNfa_1(3, active0, 0L);
4769 }
4770 private int jjStartNfaWithStates_1(int pos, int kind, int state)
4771 {
4772    jjmatchedKind = kind;
4773    jjmatchedPos = pos;
4774    try { curChar = input_stream.readChar(); }
4775    catch(java.io.IOException e) { return pos + 1; }
4776    return jjMoveNfa_1(state, pos + 1);
4777 }
4778 private int jjMoveNfa_1(int startState, int curPos)
4779 {
4780    int startsAt = 0;
4781    jjnewStateCnt = 28;
4782    int i = 1;
4783    jjstateSet[0] = startState;
4784    int kind = 0x7fffffff;
4785    for (;;)
4786    {
4787       if (++jjround == 0x7fffffff)
4788          ReInitRounds();
4789       if (curChar < 64)
4790       {
4791          long l = 1L << curChar;
4792          do
4793          {
4794             switch(jjstateSet[--i])
4795             {
4796                case 12:
4797                   if ((0x100000200L & l) != 0L)
4798                      jjCheckNAddTwoStates(0, 1);
4799                   else if (curChar == 35)
4800                      jjCheckNAddStates(231, 233);
4801                   else if (curChar == 36)
4802                   {
4803                      if (kind > 16)
4804                         kind = 16;
4805                      jjCheckNAddTwoStates(21, 22);
4806                   }
4807                   else if (curChar == 46)
4808                      jjstateSet[jjnewStateCnt++] = 15;
4809                   break;
4810                case 27:
4811                   if (curChar == 42)
4812                      jjstateSet[jjnewStateCnt++] = 25;
4813                   break;
4814                case 0:
4815                   if ((0x100000200L & l) != 0L)
4816                      jjCheckNAddTwoStates(0, 1);
4817                   break;
4818                case 1:
4819                   if (curChar == 35)
4820                      jjCheckNAddTwoStates(6, 11);
4821                   break;
4822                case 3:
4823                   if (curChar == 32)
4824                      jjAddStates(115, 116);
4825                   break;
4826                case 4:
4827                   if (curChar == 40 && kind > 15)
4828                      kind = 15;
4829                   break;
4830                case 13:
4831                   if ((0x3ff200000000000L & l) == 0L)
4832                      break;
4833                   if (kind > 68)
4834                      kind = 68;
4835                   jjstateSet[jjnewStateCnt++] = 13;
4836                   break;
4837                case 14:
4838                   if (curChar == 46)
4839                      jjstateSet[jjnewStateCnt++] = 15;
4840                   break;
4841                case 18:
4842                   if (curChar == 36 && kind > 16)
4843                      kind = 16;
4844                   break;
4845                case 20:
4846                   if (curChar == 36)
4847                      jjCheckNAddTwoStates(21, 22);
4848                   break;
4849                case 22:
4850                   if (curChar == 33 && kind > 17)
4851                      kind = 17;
4852                   break;
4853                case 23:
4854                   if (curChar != 36)
4855                      break;
4856                   if (kind > 16)
4857                      kind = 16;
4858                   jjCheckNAddTwoStates(21, 22);
4859                   break;
4860                case 24:
4861                   if (curChar == 35)
4862                      jjCheckNAddStates(231, 233);
4863                   break;
4864                case 25:
4865                   if (curChar == 42)
4866                      jjstateSet[jjnewStateCnt++] = 26;
4867                   break;
4868                case 26:
4869                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
4870                      kind = 19;
4871                   break;
4872                default : break;
4873             }
4874          } while(i != startsAt);
4875       }
4876       else if (curChar < 128)
4877       {
4878          long l = 1L << (curChar & 077);
4879          do
4880          {
4881             switch(jjstateSet[--i])
4882             {
4883                case 12:
4884                   if ((0x7fffffe87fffffeL & l) != 0L)
4885                   {
4886                      if (kind > 68)
4887                         kind = 68;
4888                      jjCheckNAdd(13);
4889                   }
4890                   else if (curChar == 92)
4891                      jjCheckNAddStates(234, 237);
4892                   break;
4893                case 27:
4894                   if ((0x8000000080000L & l) != 0L)
4895                      jjstateSet[jjnewStateCnt++] = 5;
4896                   else if (curChar == 123)
4897                      jjstateSet[jjnewStateCnt++] = 10;
4898                   break;
4899                case 2:
4900                   if ((0x10000000100000L & l) != 0L)
4901                      jjCheckNAddTwoStates(3, 4);
4902                   break;
4903                case 5:
4904                   if ((0x2000000020L & l) != 0L)
4905                      jjstateSet[jjnewStateCnt++] = 2;
4906                   break;
4907                case 6:
4908                   if ((0x8000000080000L & l) != 0L)
4909                      jjstateSet[jjnewStateCnt++] = 5;
4910                   break;
4911                case 7:
4912                   if (curChar == 125)
4913                      jjCheckNAddTwoStates(3, 4);
4914                   break;
4915                case 8:
4916                   if ((0x10000000100000L & l) != 0L)
4917                      jjstateSet[jjnewStateCnt++] = 7;
4918                   break;
4919                case 9:
4920                   if ((0x2000000020L & l) != 0L)
4921                      jjstateSet[jjnewStateCnt++] = 8;
4922                   break;
4923                case 10:
4924                   if ((0x8000000080000L & l) != 0L)
4925                      jjstateSet[jjnewStateCnt++] = 9;
4926                   break;
4927                case 11:
4928                   if (curChar == 123)
4929                      jjstateSet[jjnewStateCnt++] = 10;
4930                   break;
4931                case 13:
4932                   if ((0x7fffffe87fffffeL & l) == 0L)
4933                      break;
4934                   if (kind > 68)
4935                      kind = 68;
4936                   jjCheckNAdd(13);
4937                   break;
4938                case 15:
4939                   if ((0x7fffffe07fffffeL & l) != 0L && kind > 69)
4940                      kind = 69;
4941                   break;
4942                case 16:
4943                   if (curChar == 92)
4944                      jjCheckNAddStates(234, 237);
4945                   break;
4946                case 17:
4947                   if (curChar == 92)
4948                      jjCheckNAddTwoStates(17, 18);
4949                   break;
4950                case 19:
4951                   if (curChar == 92)
4952                      jjCheckNAddTwoStates(19, 20);
4953                   break;
4954                case 21:
4955                   if (curChar == 92)
4956                      jjAddStates(146, 147);
4957                   break;
4958                case 26:
4959                   if (kind > 19)
4960                      kind = 19;
4961                   break;
4962                default : break;
4963             }
4964          } while(i != startsAt);
4965       }
4966       else
4967       {
4968          int hiByte = (int)(curChar >> 8);
4969          int i1 = hiByte >> 6;
4970          long l1 = 1L << (hiByte & 077);
4971          int i2 = (curChar & 0xff) >> 6;
4972          long l2 = 1L << (curChar & 077);
4973          do
4974          {
4975             switch(jjstateSet[--i])
4976             {
4977                case 26:
4978                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
4979                      kind = 19;
4980                   break;
4981                default : break;
4982             }
4983          } while(i != startsAt);
4984       }
4985       if (kind != 0x7fffffff)
4986       {
4987          jjmatchedKind = kind;
4988          jjmatchedPos = curPos;
4989          kind = 0x7fffffff;
4990       }
4991       ++curPos;
4992       if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt)))
4993          return curPos;
4994       try { curChar = input_stream.readChar(); }
4995       catch(java.io.IOException e) { return curPos; }
4996    }
4997 }
4998 private final int jjStopStringLiteralDfa_7(int pos, long active0)
4999 {
5000    switch (pos)
5001    {
5002       case 0:
5003          if ((active0 & 0x340000L) != 0L)
5004             return 2;
5005          return -1;
5006       case 1:
5007          if ((active0 & 0x100000L) != 0L)
5008             return 0;
5009          return -1;
5010       default :
5011          return -1;
5012    }
5013 }
5014 private final int jjStartNfa_7(int pos, long active0)
5015 {
5016    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
5017 }
5018 private int jjMoveStringLiteralDfa0_7()
5019 {
5020    switch(curChar)
5021    {
5022       case 35:
5023          jjmatchedKind = 21;
5024          return jjMoveStringLiteralDfa1_7(0x140000L);
5025       case 93:
5026          return jjMoveStringLiteralDfa1_7(0x20000000L);
5027       default :
5028          return jjMoveNfa_7(3, 0);
5029    }
5030 }
5031 private int jjMoveStringLiteralDfa1_7(long active0)
5032 {
5033    try { curChar = input_stream.readChar(); }
5034    catch(java.io.IOException e) {
5035       jjStopStringLiteralDfa_7(0, active0);
5036       return 1;
5037    }
5038    switch(curChar)
5039    {
5040       case 42:
5041          if ((active0 & 0x100000L) != 0L)
5042             return jjStartNfaWithStates_7(1, 20, 0);
5043          break;
5044       case 91:
5045          return jjMoveStringLiteralDfa2_7(active0, 0x40000L);
5046       case 93:
5047          return jjMoveStringLiteralDfa2_7(active0, 0x20000000L);
5048       default :
5049          break;
5050    }
5051    return jjStartNfa_7(0, active0);
5052 }
5053 private int jjMoveStringLiteralDfa2_7(long old0, long active0)
5054 {
5055    if (((active0 &= old0)) == 0L)
5056       return jjStartNfa_7(0, old0);
5057    try { curChar = input_stream.readChar(); }
5058    catch(java.io.IOException e) {
5059       jjStopStringLiteralDfa_7(1, active0);
5060       return 2;
5061    }
5062    switch(curChar)
5063    {
5064       case 35:
5065          if ((active0 & 0x20000000L) != 0L)
5066             return jjStopAtPos(2, 29);
5067          break;
5068       case 91:
5069          if ((active0 & 0x40000L) != 0L)
5070             return jjStopAtPos(2, 18);
5071          break;
5072       default :
5073          break;
5074    }
5075    return jjStartNfa_7(1, active0);
5076 }
5077 private int jjStartNfaWithStates_7(int pos, int kind, int state)
5078 {
5079    jjmatchedKind = kind;
5080    jjmatchedPos = pos;
5081    try { curChar = input_stream.readChar(); }
5082    catch(java.io.IOException e) { return pos + 1; }
5083    return jjMoveNfa_7(state, pos + 1);
5084 }
5085 private int jjMoveNfa_7(int startState, int curPos)
5086 {
5087    int startsAt = 0;
5088    jjnewStateCnt = 12;
5089    int i = 1;
5090    jjstateSet[0] = startState;
5091    int kind = 0x7fffffff;
5092    for (;;)
5093    {
5094       if (++jjround == 0x7fffffff)
5095          ReInitRounds();
5096       if (curChar < 64)
5097       {
5098          long l = 1L << curChar;
5099          do
5100          {
5101             switch(jjstateSet[--i])
5102             {
5103                case 3:
5104                   if (curChar == 36)
5105                   {
5106                      if (kind > 16)
5107                         kind = 16;
5108                      jjCheckNAddTwoStates(9, 10);
5109                   }
5110                   else if (curChar == 35)
5111                      jjstateSet[jjnewStateCnt++] = 2;
5112                   break;
5113                case 0:
5114                   if (curChar == 42)
5115                      jjstateSet[jjnewStateCnt++] = 1;
5116                   break;
5117                case 1:
5118                   if ((0xfffffff7ffffffffL & l) != 0L && kind > 19)
5119                      kind = 19;
5120                   break;
5121                case 2:
5122                   if (curChar == 42)
5123                      jjstateSet[jjnewStateCnt++] = 0;
5124                   break;
5125                case 6:
5126                   if (curChar == 36 && kind > 16)
5127                      kind = 16;
5128                   break;
5129                case 8:
5130                   if (curChar == 36)
5131                      jjCheckNAddTwoStates(9, 10);
5132                   break;
5133                case 10:
5134                   if (curChar == 33 && kind > 17)
5135                      kind = 17;
5136                   break;
5137                case 11:
5138                   if (curChar != 36)
5139                      break;
5140                   if (kind > 16)
5141                      kind = 16;
5142                   jjCheckNAddTwoStates(9, 10);
5143                   break;
5144                default : break;
5145             }
5146          } while(i != startsAt);
5147       }
5148       else if (curChar < 128)
5149       {
5150          long l = 1L << (curChar & 077);
5151          do
5152          {
5153             switch(jjstateSet[--i])
5154             {
5155                case 3:
5156                   if (curChar == 92)
5157                      jjCheckNAddStates(100, 103);
5158                   break;
5159                case 1:
5160                   if (kind > 19)
5161                      kind = 19;
5162                   break;
5163                case 5:
5164                   if (curChar == 92)
5165                      jjCheckNAddTwoStates(5, 6);
5166                   break;
5167                case 7:
5168                   if (curChar == 92)
5169                      jjCheckNAddTwoStates(7, 8);
5170                   break;
5171                case 9:
5172                   if (curChar == 92)
5173                      jjAddStates(104, 105);
5174                   break;
5175                default : break;
5176             }
5177          } while(i != startsAt);
5178       }
5179       else
5180       {
5181          int hiByte = (int)(curChar >> 8);
5182          int i1 = hiByte >> 6;
5183          long l1 = 1L << (hiByte & 077);
5184          int i2 = (curChar & 0xff) >> 6;
5185          long l2 = 1L << (curChar & 077);
5186          do
5187          {
5188             switch(jjstateSet[--i])
5189             {
5190                case 1:
5191                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 19)
5192                      kind = 19;
5193                   break;
5194                default : break;
5195             }
5196          } while(i != startsAt);
5197       }
5198       if (kind != 0x7fffffff)
5199       {
5200          jjmatchedKind = kind;
5201          jjmatchedPos = curPos;
5202          kind = 0x7fffffff;
5203       }
5204       ++curPos;
5205       if ((i = jjnewStateCnt) == (startsAt = 12 - (jjnewStateCnt = startsAt)))
5206          return curPos;
5207       try { curChar = input_stream.readChar(); }
5208       catch(java.io.IOException e) { return curPos; }
5209    }
5210 }
5211 static final int[] jjnextStates = {
5212    91, 93, 94, 95, 100, 101, 91, 94, 61, 100, 29, 31, 32, 35, 11, 13, 
5213    14, 15, 1, 2, 4, 11, 18, 13, 14, 15, 26, 27, 33, 34, 70, 71, 
5214    73, 74, 75, 76, 87, 89, 84, 85, 81, 82, 16, 17, 19, 21, 26, 27, 
5215    64, 65, 77, 78, 98, 99, 102, 103, 84, 86, 87, 88, 93, 94, 84, 87, 
5216    13, 93, 22, 23, 34, 35, 37, 45, 46, 48, 53, 35, 54, 77, 46, 78, 
5217    57, 65, 68, 75, 82, 25, 26, 27, 28, 38, 43, 50, 16, 17, 29, 30, 
5218    91, 92, 95, 96, 5, 6, 7, 8, 9, 10, 6, 11, 39, 14, 15, 17, 
5219    18, 22, 24, 3, 4, 20, 21, 29, 30, 31, 32, 45, 47, 48, 49, 54, 
5220    55, 45, 48, 31, 54, 24, 26, 27, 30, 6, 8, 9, 10, 6, 13, 8, 
5221    9, 10, 21, 22, 28, 29, 37, 38, 39, 40, 11, 12, 14, 16, 21, 22, 
5222    34, 35, 41, 42, 52, 53, 56, 57, 8, 9, 10, 11, 12, 13, 6, 11, 
5223    33, 17, 18, 20, 21, 23, 24, 25, 26, 27, 28, 54, 56, 57, 58, 68, 
5224    69, 54, 57, 63, 68, 6, 11, 52, 32, 34, 35, 38, 14, 16, 17, 18, 
5225    14, 21, 16, 17, 18, 36, 37, 42, 43, 44, 45, 19, 20, 22, 24, 29, 
5226    30, 46, 47, 61, 62, 66, 67, 6, 11, 27, 17, 18, 19, 20, 
5227 };
5228 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
5229 {
5230    switch(hiByte)
5231    {
5232       case 0:
5233          return ((jjbitVec2[i2] & l2) != 0L);
5234       default :
5235          if ((jjbitVec0[i1] & l1) != 0L)
5236             return true;
5237          return false;
5238    }
5239 }
5240 
5241 /** Token literal values. */
5242 public static final String[] jjstrLiteralImages = {
5243 null, null, null, null, null, null, null, null, null, null, null, null, null, 
5244 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
5245 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
5246 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
5247 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
5248 null, null, null, null, null, null, };
5249 
5250 /** Lexer state names. */
5251 public static final String[] lexStateNames = {
5252    "REFERENCE",
5253    "REFMODIFIER",
5254    "REFINDEX",
5255    "DIRECTIVE",
5256    "REFMOD2",
5257    "DEFAULT",
5258    "REFMOD",
5259    "IN_TEXTBLOCK",
5260    "IN_MULTI_LINE_COMMENT",
5261    "IN_FORMAL_COMMENT",
5262    "IN_SINGLE_LINE_COMMENT",
5263    "PRE_DIRECTIVE",
5264 };
5265 
5266 /** Lex State array. */
5267 public static final int[] jjnewLexState = {
5268    -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, 
5269    -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, 
5270    -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, 
5271 };
5272 static final long[] jjtoToken = {
5273    0x8dffffff3fc0ffffL, 0x4f1L, 
5274 };
5275 static final long[] jjtoSkip = {
5276    0x40000000L, 0x300L, 
5277 };
5278 static final long[] jjtoSpecial = {
5279    0x0L, 0x300L, 
5280 };
5281 static final long[] jjtoMore = {
5282    0x803f0000L, 0x0L, 
5283 };
5284 protected CharStream input_stream;
5285 private final int[] jjrounds = new int[105];
5286 private final int[] jjstateSet = new int[210];
5287 private final StringBuilder jjimage = new StringBuilder();
5288 private StringBuilder image = jjimage;
5289 private int jjimageLen;
5290 private int lengthOfMatch;
5291 protected char curChar;
5292 /** Constructor. */
5293 public VmParserTokenManager(CharStream stream){
5294    input_stream = stream;
5295 }
5296 
5297 /** Constructor. */
5298 public VmParserTokenManager(CharStream stream, int lexState){
5299    this(stream);
5300    SwitchTo(lexState);
5301 }
5302 
5303 /** Reinitialise parser. */
5304 public void ReInit(CharStream stream)
5305 {
5306    jjmatchedPos = jjnewStateCnt = 0;
5307    curLexState = defaultLexState;
5308    input_stream = stream;
5309    ReInitRounds();
5310 }
5311 private void ReInitRounds()
5312 {
5313    int i;
5314    jjround = 0x80000001;
5315    for (i = 105; i-- > 0;)
5316       jjrounds[i] = 0x80000000;
5317 }
5318 
5319 /** Reinitialise parser. */
5320 public void ReInit(CharStream stream, int lexState)
5321 {
5322    ReInit(stream);
5323    SwitchTo(lexState);
5324 }
5325 
5326 /** Switch to specified lex state. */
5327 public void SwitchTo(int lexState)
5328 {
5329    if (lexState >= 12 || lexState < 0)
5330       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
5331    else
5332       curLexState = lexState;
5333 }
5334 
5335 protected Token jjFillToken()
5336 {
5337    final Token t;
5338    final String curTokenImage;
5339    final int beginLine;
5340    final int endLine;
5341    final int beginColumn;
5342    final int endColumn;
5343    String im = jjstrLiteralImages[jjmatchedKind];
5344    curTokenImage = (im == null) ? input_stream.GetImage() : im;
5345    beginLine = input_stream.getBeginLine();
5346    beginColumn = input_stream.getBeginColumn();
5347    endLine = input_stream.getEndLine();
5348    endColumn = input_stream.getEndColumn();
5349    t = Token.newToken(jjmatchedKind, curTokenImage);
5350 
5351    t.beginLine = beginLine;
5352    t.endLine = endLine;
5353    t.beginColumn = beginColumn;
5354    t.endColumn = endColumn;
5355 
5356    return t;
5357 }
5358 
5359 int curLexState = 5;
5360 int defaultLexState = 5;
5361 int jjnewStateCnt;
5362 int jjround;
5363 int jjmatchedPos;
5364 int jjmatchedKind;
5365 
5366 /** Get the next Token. */
5367 public Token getNextToken() 
5368 {
5369   Token specialToken = null;
5370   Token matchedToken;
5371   int curPos = 0;
5372 
5373   EOFLoop :
5374   for (;;)
5375   {
5376    try
5377    {
5378       curChar = input_stream.BeginToken();
5379    }
5380    catch(java.io.IOException e)
5381    {
5382       jjmatchedKind = 0;
5383       matchedToken = jjFillToken();
5384       matchedToken.specialToken = specialToken;
5385       return matchedToken;
5386    }
5387    image = jjimage;
5388    image.setLength(0);
5389    jjimageLen = 0;
5390 
5391    for (;;)
5392    {
5393      switch(curLexState)
5394      {
5395        case 0:
5396          jjmatchedKind = 0x7fffffff;
5397          jjmatchedPos = 0;
5398          curPos = jjMoveStringLiteralDfa0_0();
5399          if (jjmatchedPos == 0 && jjmatchedKind > 72)
5400          {
5401             jjmatchedKind = 72;
5402          }
5403          break;
5404        case 1:
5405          jjmatchedKind = 0x7fffffff;
5406          jjmatchedPos = 0;
5407          curPos = jjMoveStringLiteralDfa0_1();
5408          if (jjmatchedPos == 0 && jjmatchedKind > 72)
5409          {
5410             jjmatchedKind = 72;
5411          }
5412          break;
5413        case 2:
5414          jjmatchedKind = 0x7fffffff;
5415          jjmatchedPos = 0;
5416          curPos = jjMoveStringLiteralDfa0_2();
5417          break;
5418        case 3:
5419          jjmatchedKind = 0x7fffffff;
5420          jjmatchedPos = 0;
5421          curPos = jjMoveStringLiteralDfa0_3();
5422          break;
5423        case 4:
5424          jjmatchedKind = 0x7fffffff;
5425          jjmatchedPos = 0;
5426          curPos = jjMoveStringLiteralDfa0_4();
5427          break;
5428        case 5:
5429          jjmatchedKind = 0x7fffffff;
5430          jjmatchedPos = 0;
5431          curPos = jjMoveStringLiteralDfa0_5();
5432          break;
5433        case 6:
5434          jjmatchedKind = 0x7fffffff;
5435          jjmatchedPos = 0;
5436          curPos = jjMoveStringLiteralDfa0_6();
5437          if (jjmatchedPos == 0 && jjmatchedKind > 72)
5438          {
5439             jjmatchedKind = 72;
5440          }
5441          break;
5442        case 7:
5443          jjmatchedKind = 0x7fffffff;
5444          jjmatchedPos = 0;
5445          curPos = jjMoveStringLiteralDfa0_7();
5446          if (jjmatchedPos == 0 && jjmatchedKind > 31)
5447          {
5448             jjmatchedKind = 31;
5449          }
5450          break;
5451        case 8:
5452          jjmatchedKind = 0x7fffffff;
5453          jjmatchedPos = 0;
5454          curPos = jjMoveStringLiteralDfa0_8();
5455          if (jjmatchedPos == 0 && jjmatchedKind > 30)
5456          {
5457             jjmatchedKind = 30;
5458          }
5459          break;
5460        case 9:
5461          jjmatchedKind = 0x7fffffff;
5462          jjmatchedPos = 0;
5463          curPos = jjMoveStringLiteralDfa0_9();
5464          if (jjmatchedPos == 0 && jjmatchedKind > 30)
5465          {
5466             jjmatchedKind = 30;
5467          }
5468          break;
5469        case 10:
5470          jjmatchedKind = 0x7fffffff;
5471          jjmatchedPos = 0;
5472          curPos = jjMoveStringLiteralDfa0_10();
5473          if (jjmatchedPos == 0 && jjmatchedKind > 30)
5474          {
5475             jjmatchedKind = 30;
5476          }
5477          break;
5478        case 11:
5479          jjmatchedKind = 0x7fffffff;
5480          jjmatchedPos = 0;
5481          curPos = jjMoveStringLiteralDfa0_11();
5482          if (jjmatchedPos == 0 && jjmatchedKind > 73)
5483          {
5484             jjmatchedKind = 73;
5485          }
5486          break;
5487      }
5488      if (jjmatchedKind != 0x7fffffff)
5489      {
5490         if (jjmatchedPos + 1 < curPos)
5491            input_stream.backup(curPos - jjmatchedPos - 1);
5492         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5493         {
5494            matchedToken = jjFillToken();
5495            matchedToken.specialToken = specialToken;
5496            TokenLexicalActions(matchedToken);
5497        if (jjnewLexState[jjmatchedKind] != -1)
5498          curLexState = jjnewLexState[jjmatchedKind];
5499            return matchedToken;
5500         }
5501         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5502         {
5503            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
5504            {
5505               matchedToken = jjFillToken();
5506               if (specialToken == null)
5507                  specialToken = matchedToken;
5508               else
5509               {
5510                  matchedToken.specialToken = specialToken;
5511                  specialToken = (specialToken.next = matchedToken);
5512               }
5513               SkipLexicalActions(matchedToken);
5514            }
5515            else
5516               SkipLexicalActions(null);
5517          if (jjnewLexState[jjmatchedKind] != -1)
5518            curLexState = jjnewLexState[jjmatchedKind];
5519            continue EOFLoop;
5520         }
5521         MoreLexicalActions();
5522       if (jjnewLexState[jjmatchedKind] != -1)
5523         curLexState = jjnewLexState[jjmatchedKind];
5524         curPos = 0;
5525         jjmatchedKind = 0x7fffffff;
5526         try {
5527            curChar = input_stream.readChar();
5528            continue;
5529         }
5530         catch (java.io.IOException e1) { }
5531      }
5532      int error_line = input_stream.getEndLine();
5533      int error_column = input_stream.getEndColumn();
5534      String error_after = null;
5535      boolean EOFSeen = false;
5536      try { input_stream.readChar(); input_stream.backup(1); }
5537      catch (java.io.IOException e1) {
5538         EOFSeen = true;
5539         error_after = curPos <= 1 ? "" : input_stream.GetImage();
5540         if (curChar == '\n' || curChar == '\r') {
5541            error_line++;
5542            error_column = 0;
5543         }
5544         else
5545            error_column++;
5546      }
5547      if (!EOFSeen) {
5548         input_stream.backup(1);
5549         error_after = curPos <= 1 ? "" : input_stream.GetImage();
5550      }
5551      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
5552    }
5553   }
5554 }
5555 
5556 void SkipLexicalActions(Token matchedToken)
5557 {
5558    switch(jjmatchedKind)
5559    {
5560       case 72 :
5561          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5562         /*
5563          * push every terminator character back into the stream
5564          */
5565 
5566         input_stream.backup(1);
5567 
5568         inReference = false;
5569 
5570         if ( debugPrint )
5571             System.out.print("REF_TERM :");
5572 
5573         stateStackPop();
5574          break;
5575       case 73 :
5576          image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5577         if ( debugPrint )
5578             System.out.print("DIRECTIVE_TERM :");
5579 
5580         input_stream.backup(1);
5581         inDirective = false;
5582         stateStackPop();
5583          break;
5584       default :
5585          break;
5586    }
5587 }
5588 void MoreLexicalActions()
5589 {
5590    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
5591    switch(jjmatchedKind)
5592    {
5593       case 16 :
5594          image.append(input_stream.GetSuffix(jjimageLen));
5595          jjimageLen = 0;
5596         if (! inComment)
5597         {
5598             /*
5599              * if we find ourselves in REFERENCE, we need to pop down
5600              * to end the previous ref
5601              */
5602 
5603             if (curLexState == REFERENCE)
5604             {
5605                 inReference = false;
5606                 stateStackPop();
5607             }
5608 
5609             inReference = true;
5610 
5611             if ( debugPrint )
5612                 System.out.print( "$  : going to " + REFERENCE );
5613 
5614             stateStackPush();
5615             SwitchTo(REFERENCE);
5616         }
5617          break;
5618       case 17 :
5619          image.append(input_stream.GetSuffix(jjimageLen));
5620          jjimageLen = 0;
5621         if (! inComment)
5622         {
5623             /*
5624              * if we find ourselves in REFERENCE, we need to pop down
5625              * to end the previous ref
5626              */
5627 
5628             if (curLexState == REFERENCE)
5629             {
5630                 inReference = false;
5631                 stateStackPop();
5632             }
5633 
5634             inReference = true;
5635 
5636             if ( debugPrint )
5637                 System.out.print( "$!  : going to " + REFERENCE );
5638 
5639             stateStackPush();
5640             SwitchTo(REFERENCE);
5641         }
5642          break;
5643       case 18 :
5644          image.append(input_stream.GetSuffix(jjimageLen));
5645          jjimageLen = 0;
5646        if (!inComment)
5647        {
5648            inComment = true;
5649            stateStackPush();
5650            SwitchTo( IN_TEXTBLOCK );
5651        }
5652          break;
5653       case 19 :
5654          image.append(input_stream.GetSuffix(jjimageLen));
5655          jjimageLen = 0;
5656         if (!inComment)
5657         {
5658                 input_stream.backup(1);
5659                 inComment = true;
5660                 stateStackPush();
5661                 SwitchTo( IN_FORMAL_COMMENT);
5662         }
5663          break;
5664       case 20 :
5665          image.append(input_stream.GetSuffix(jjimageLen));
5666          jjimageLen = 0;
5667         if (!inComment)
5668         {
5669                 inComment=true;
5670                 stateStackPush();
5671                 SwitchTo( IN_MULTI_LINE_COMMENT );
5672         }
5673          break;
5674       case 21 :
5675          image.append(input_stream.GetSuffix(jjimageLen));
5676          jjimageLen = 0;
5677         if (! inComment)
5678         {
5679             /*
5680              * We can have the situation where #if($foo)$foo#end.
5681              * We need to transition out of REFERENCE before going to DIRECTIVE.
5682              * I don't really like this, but I can't think of a legal way
5683              * you are going into DIRECTIVE while in REFERENCE.  -gmj
5684              */
5685 
5686             if (curLexState == REFERENCE || curLexState == REFMODIFIER )
5687             {
5688                 inReference = false;
5689                 stateStackPop();
5690             }
5691 
5692             inDirective = true;
5693 
5694             if ( debugPrint )
5695                 System.out.print("# :  going to " + DIRECTIVE );
5696 
5697             stateStackPush();
5698             SwitchTo(PRE_DIRECTIVE);
5699         }
5700          break;
5701       default :
5702          break;
5703    }
5704 }
5705 void TokenLexicalActions(Token matchedToken)
5706 {
5707    switch(jjmatchedKind)
5708    {
5709       case 1 :
5710         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5711      stateStackPush();
5712      SwitchTo(REFINDEX);
5713          break;
5714       case 2 :
5715         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5716      stateStackPop();
5717          break;
5718       case 11 :
5719         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5720         if (!inComment)
5721             lparen++;
5722 
5723         /*
5724          * If in REFERENCE and we have seen the dot, then move
5725          * to REFMOD2 -> Modifier()
5726          */
5727 
5728         if (curLexState == REFMODIFIER )
5729             SwitchTo( REFMOD2 );
5730          break;
5731       case 12 :
5732         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5733        RPARENHandler();
5734          break;
5735       case 13 :
5736         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5737         /*
5738          * need to simply switch back to REFERENCE, not drop down the stack
5739          * because we can (infinitely) chain, ala
5740          * $foo.bar().blargh().woogie().doogie()
5741          */
5742 
5743         SwitchTo( REFERENCE );
5744          break;
5745       case 15 :
5746         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5747         if (! inComment)
5748         {
5749             inDirective = true;
5750 
5751             if ( debugPrint )
5752                 System.out.print("#set :  going to " + DIRECTIVE );
5753 
5754             stateStackPush();
5755             inSet = true;
5756             SwitchTo(DIRECTIVE);
5757         }
5758 
5759         /*
5760          *  need the LPAREN action
5761          */
5762 
5763         if (!inComment)
5764         {
5765             lparen++;
5766 
5767             /*
5768              * If in REFERENCE and we have seen the dot, then move
5769              * to REFMOD2 -> Modifier()
5770              */
5771 
5772             if (curLexState == REFMODIFIER )
5773                 SwitchTo( REFMOD2 );
5774         }
5775          break;
5776       case 22 :
5777         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5778         if (!inComment)
5779         {
5780             if (curLexState == REFERENCE)
5781             {
5782                 inReference = false;
5783                 stateStackPop();
5784             }
5785 
5786             inComment = true;
5787             stateStackPush();
5788             SwitchTo(IN_SINGLE_LINE_COMMENT);
5789         }
5790          break;
5791       case 26 :
5792         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5793      inComment = false;
5794      stateStackPop();
5795          break;
5796       case 27 :
5797         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5798     inComment = false;
5799     stateStackPop();
5800          break;
5801       case 28 :
5802         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5803     inComment = false;
5804     stateStackPop();
5805          break;
5806       case 29 :
5807         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5808     inComment = false;
5809     stateStackPop();
5810          break;
5811       case 33 :
5812         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5813         /*
5814          *  - if we are in DIRECTIVE and haven't seen ( yet, then also drop out.
5815          *      don't forget to account for the beloved yet wierd #set
5816          *  - finally, if we are in REFMOD2 (remember : $foo.bar( ) then " is ok!
5817          */
5818 
5819          if( curLexState == DIRECTIVE && !inSet && lparen == 0)
5820             stateStackPop();
5821          break;
5822       case 36 :
5823         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5824         if ( debugPrint )
5825             System.out.println(" NEWLINE :");
5826 
5827         stateStackPop();
5828 
5829         if (inSet)
5830             inSet = false;
5831 
5832         if (inDirective)
5833             inDirective = false;
5834          break;
5835       case 52 :
5836         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5837         inDirective = false;
5838         stateStackPop();
5839          break;
5840       case 53 :
5841         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5842         SwitchTo(DIRECTIVE);
5843          break;
5844       case 54 :
5845         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5846         SwitchTo(DIRECTIVE);
5847          break;
5848       case 55 :
5849         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5850         SwitchTo(DIRECTIVE);
5851          break;
5852       case 56 :
5853         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5854         inDirective = false;
5855         stateStackPop();
5856          break;
5857       case 58 :
5858         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5859         /*
5860          * Remove the double period if it is there
5861          */
5862         if (matchedToken.image.endsWith("..")) {
5863             input_stream.backup(2);
5864             matchedToken.image = matchedToken.image.substring(0,matchedToken.image.length()-2);
5865         }
5866 
5867         /*
5868          * check to see if we are in set
5869          *    ex.  #set $foo = $foo + 3
5870          *  because we want to handle the \n after
5871          */
5872 
5873         if ( lparen == 0 && !inSet && curLexState != REFMOD2 && curLexState != REFINDEX)
5874         {
5875             stateStackPop();
5876         }
5877          break;
5878       case 59 :
5879         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5880         /*
5881          * check to see if we are in set
5882          *    ex.  #set $foo = $foo + 3
5883          *  because we want to handle the \n after
5884          */
5885 
5886         if ( lparen == 0 && !inSet && curLexState != REFMOD2)
5887         {
5888             stateStackPop();
5889     }
5890          break;
5891       case 69 :
5892         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5893         /*
5894          * push the alpha char back into the stream so the following identifier
5895          * is complete
5896          */
5897 
5898         input_stream.backup(1);
5899 
5900         /*
5901          * and munge the <DOT> so we just get a . when we have normal text that
5902          * looks like a ref.ident
5903          */
5904 
5905         matchedToken.image = ".";
5906 
5907         if ( debugPrint )
5908             System.out.print("DOT : switching to " + REFMODIFIER);
5909         SwitchTo(REFMODIFIER);
5910          break;
5911       case 71 :
5912         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
5913         stateStackPop();
5914          break;
5915       default :
5916          break;
5917    }
5918 }
5919 private void jjCheckNAdd(int state)
5920 {
5921    if (jjrounds[state] != jjround)
5922    {
5923       jjstateSet[jjnewStateCnt++] = state;
5924       jjrounds[state] = jjround;
5925    }
5926 }
5927 private void jjAddStates(int start, int end)
5928 {
5929    do {
5930       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
5931    } while (start++ != end);
5932 }
5933 private void jjCheckNAddTwoStates(int state1, int state2)
5934 {
5935    jjCheckNAdd(state1);
5936    jjCheckNAdd(state2);
5937 }
5938 
5939 private void jjCheckNAddStates(int start, int end)
5940 {
5941    do {
5942       jjCheckNAdd(jjnextStates[start]);
5943    } while (start++ != end);
5944 }
5945 
5946 }