Source for org.w3c.flute.parser.ParserTokenManager

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