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