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