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