View Javadoc

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