net.sourceforge.phpeclipse/src/test/PHPParserTokenManager.java

   1 /* Generated By:JavaCC: Do not edit this line. PHPParserTokenManager.java */
   2 package test;
   3
   4 public class PHPParserTokenManager implements PHPParserConstants
   5 {
   6   // CommonTokenAction: use the begins/ends fields added to the Jack
   7   // CharStream class to set corresponding fields in each Token (which was
   8   // also extended with new fields). By default Jack doesn't supply absolute
   9   // offsets, just line/column offsets
  10   static void CommonTokenAction(Token t) {
  11     t.sourceStart = input_stream.beginOffset;
  12     t.sourceEnd = input_stream.endOffset;
  13   }
  14   public static  java.io.PrintStream debugStream = System.out;
  15   public static  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
  16 static private final int jjStopAtPos(int pos, int kind)
  17 {
  18    jjmatchedKind = kind;
  19    jjmatchedPos = pos;
  20    return pos + 1;
  21 }
  22 static private final int jjMoveStringLiteralDfa0_5()
  23 {
  24    switch(curChar)
  25    {
  26       case 42:
  27          return jjMoveStringLiteralDfa1_5(0x2000000L);
  28       case 84:
  29       case 116:
  30          return jjMoveStringLiteralDfa1_5(0x400000L);
  31       default :
  32          return 1;
  33    }
  34 }
  35 static private final int jjMoveStringLiteralDfa1_5(long active0)
  36 {
  37    try { curChar = input_stream.readChar(); }
  38    catch(java.io.IOException e) {
  39       return 1;
  40    }
  41    switch(curChar)
  42    {
  43       case 47:
  44          if ((active0 & 0x2000000L) != 0L)
  45             return jjStopAtPos(1, 25);
  46          break;
  47       case 79:
  48       case 111:
  49          return jjMoveStringLiteralDfa2_5(active0, 0x400000L);
  50       default :
  51          return 2;
  52    }
  53    return 2;
  54 }
  55 static private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
  56 {
  57    if (((active0 &= old0)) == 0L)
  58       return 2;
  59    try { curChar = input_stream.readChar(); }
  60    catch(java.io.IOException e) {
  61       return 2;
  62    }
  63    switch(curChar)
  64    {
  65       case 68:
  66       case 100:
  67          return jjMoveStringLiteralDfa3_5(active0, 0x400000L);
  68       default :
  69          return 3;
  70    }
  71 }
  72 static private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
  73 {
  74    if (((active0 &= old0)) == 0L)
  75       return 3;
  76    try { curChar = input_stream.readChar(); }
  77    catch(java.io.IOException e) {
  78       return 3;
  79    }
  80    switch(curChar)
  81    {
  82       case 79:
  83       case 111:
  84          if ((active0 & 0x400000L) != 0L)
  85             return jjStopAtPos(3, 22);
  86          break;
  87       default :
  88          return 4;
  89    }
  90    return 4;
  91 }
  92 static private final int jjMoveStringLiteralDfa0_8()
  93 {
  94    switch(curChar)
  95    {
  96       case 125:
  97          return jjStopAtPos(0, 117);
  98       default :
  99          return 1;
 100    }
 101 }
 102 private static final int jjStopStringLiteralDfa_9(int pos, long active0, long active1)
 103 {
 104    switch (pos)
 105    {
 106       default :
 107          return -1;
 108    }
 109 }
 110 private static final int jjStartNfa_9(int pos, long active0, long active1)
 111 {
 112    return jjMoveNfa_9(jjStopStringLiteralDfa_9(pos, active0, active1), pos + 1);
 113 }
 114 static private final int jjStartNfaWithStates_9(int pos, int kind, int state)
 115 {
 116    jjmatchedKind = kind;
 117    jjmatchedPos = pos;
 118    try { curChar = input_stream.readChar(); }
 119    catch(java.io.IOException e) { return pos + 1; }
 120    return jjMoveNfa_9(state, pos + 1);
 121 }
 122 static private final int jjMoveStringLiteralDfa0_9()
 123 {
 124    switch(curChar)
 125    {
 126       case 125:
 127          return jjStopAtPos(0, 119);
 128       default :
 129          return jjMoveNfa_9(0, 0);
 130    }
 131 }
 132 static private final void jjCheckNAdd(int state)
 133 {
 134    if (jjrounds[state] != jjround)
 135    {
 136       jjstateSet[jjnewStateCnt++] = state;
 137       jjrounds[state] = jjround;
 138    }
 139 }
 140 static private final void jjAddStates(int start, int end)
 141 {
 142    do {
 143       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 144    } while (start++ != end);
 145 }
 146 static private final void jjCheckNAddTwoStates(int state1, int state2)
 147 {
 148    jjCheckNAdd(state1);
 149    jjCheckNAdd(state2);
 150 }
 151 static private final void jjCheckNAddStates(int start, int end)
 152 {
 153    do {
 154       jjCheckNAdd(jjnextStates[start]);
 155    } while (start++ != end);
 156 }
 157 static private final void jjCheckNAddStates(int start)
 158 {
 159    jjCheckNAdd(jjnextStates[start]);
 160    jjCheckNAdd(jjnextStates[start + 1]);
 161 }
 162 static final long[] jjbitVec0 = {
 163    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 164 };
 165 static private final int jjMoveNfa_9(int startState, int curPos)
 166 {
 167    int[] nextStates;
 168    int startsAt = 0;
 169    jjnewStateCnt = 1;
 170    int i = 1;
 171    jjstateSet[0] = startState;
 172    int j, kind = 0x7fffffff;
 173    for (;;)
 174    {
 175       if (++jjround == 0x7fffffff)
 176          ReInitRounds();
 177       if (curChar < 64)
 178       {
 179          long l = 1L << curChar;
 180          MatchLoop: do
 181          {
 182             switch(jjstateSet[--i])
 183             {
 184                case 0:
 185                   kind = 120;
 186                   jjstateSet[jjnewStateCnt++] = 0;
 187                   break;
 188                default : break;
 189             }
 190          } while(i != startsAt);
 191       }
 192       else if (curChar < 128)
 193       {
 194          long l = 1L << (curChar & 077);
 195          MatchLoop: do
 196          {
 197             switch(jjstateSet[--i])
 198             {
 199                case 0:
 200                   if ((0xdfffffffffffffffL & l) == 0L)
 201                      break;
 202                   kind = 120;
 203                   jjstateSet[jjnewStateCnt++] = 0;
 204                   break;
 205                default : break;
 206             }
 207          } while(i != startsAt);
 208       }
 209       else
 210       {
 211          int i2 = (curChar & 0xff) >> 6;
 212          long l2 = 1L << (curChar & 077);
 213          MatchLoop: do
 214          {
 215             switch(jjstateSet[--i])
 216             {
 217                case 0:
 218                   if ((jjbitVec0[i2] & l2) == 0L)
 219                      break;
 220                   if (kind > 120)
 221                      kind = 120;
 222                   jjstateSet[jjnewStateCnt++] = 0;
 223                   break;
 224                default : break;
 225             }
 226          } while(i != startsAt);
 227       }
 228       if (kind != 0x7fffffff)
 229       {
 230          jjmatchedKind = kind;
 231          jjmatchedPos = curPos;
 232          kind = 0x7fffffff;
 233       }
 234       ++curPos;
 235       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 236          return curPos;
 237       try { curChar = input_stream.readChar(); }
 238       catch(java.io.IOException e) { return curPos; }
 239    }
 240 }
 241 static private final int jjMoveStringLiteralDfa0_0()
 242 {
 243    switch(curChar)
 244    {
 245       case 60:
 246          return jjMoveStringLiteralDfa1_0(0xeL);
 247       case 84:
 248       case 116:
 249          return jjMoveStringLiteralDfa1_0(0x800000L);
 250       default :
 251          return 1;
 252    }
 253 }
 254 static private final int jjMoveStringLiteralDfa1_0(long active0)
 255 {
 256    try { curChar = input_stream.readChar(); }
 257    catch(java.io.IOException e) {
 258       return 1;
 259    }
 260    switch(curChar)
 261    {
 262       case 63:
 263          if ((active0 & 0x2L) != 0L)
 264          {
 265             jjmatchedKind = 1;
 266             jjmatchedPos = 1;
 267          }
 268          return jjMoveStringLiteralDfa2_0(active0, 0xcL);
 269       case 79:
 270       case 111:
 271          return jjMoveStringLiteralDfa2_0(active0, 0x800000L);
 272       default :
 273          return 2;
 274    }
 275 }
 276 static private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
 277 {
 278    if (((active0 &= old0)) == 0L)
 279       return 2;
 280    try { curChar = input_stream.readChar(); }
 281    catch(java.io.IOException e) {
 282       return 2;
 283    }
 284    switch(curChar)
 285    {
 286       case 61:
 287          if ((active0 & 0x8L) != 0L)
 288             return jjStopAtPos(2, 3);
 289          break;
 290       case 68:
 291       case 100:
 292          return jjMoveStringLiteralDfa3_0(active0, 0x800000L);
 293       case 80:
 294       case 112:
 295          return jjMoveStringLiteralDfa3_0(active0, 0x4L);
 296       default :
 297          return 3;
 298    }
 299    return 3;
 300 }
 301 static private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
 302 {
 303    if (((active0 &= old0)) == 0L)
 304       return 3;
 305    try { curChar = input_stream.readChar(); }
 306    catch(java.io.IOException e) {
 307       return 3;
 308    }
 309    switch(curChar)
 310    {
 311       case 72:
 312       case 104:
 313          return jjMoveStringLiteralDfa4_0(active0, 0x4L);
 314       case 79:
 315       case 111:
 316          if ((active0 & 0x800000L) != 0L)
 317             return jjStopAtPos(3, 23);
 318          break;
 319       default :
 320          return 4;
 321    }
 322    return 4;
 323 }
 324 static private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
 325 {
 326    if (((active0 &= old0)) == 0L)
 327       return 4;
 328    try { curChar = input_stream.readChar(); }
 329    catch(java.io.IOException e) {
 330       return 4;
 331    }
 332    switch(curChar)
 333    {
 334       case 80:
 335       case 112:
 336          if ((active0 & 0x4L) != 0L)
 337             return jjStopAtPos(4, 2);
 338          break;
 339       default :
 340          return 5;
 341    }
 342    return 5;
 343 }
 344 static private final int jjMoveStringLiteralDfa0_4()
 345 {
 346    switch(curChar)
 347    {
 348       case 42:
 349          return jjMoveStringLiteralDfa1_4(0x1000000L);
 350       case 84:
 351       case 116:
 352          return jjMoveStringLiteralDfa1_4(0x400000L);
 353       default :
 354          return 1;
 355    }
 356 }
 357 static private final int jjMoveStringLiteralDfa1_4(long active0)
 358 {
 359    try { curChar = input_stream.readChar(); }
 360    catch(java.io.IOException e) {
 361       return 1;
 362    }
 363    switch(curChar)
 364    {
 365       case 47:
 366          if ((active0 & 0x1000000L) != 0L)
 367             return jjStopAtPos(1, 24);
 368          break;
 369       case 79:
 370       case 111:
 371          return jjMoveStringLiteralDfa2_4(active0, 0x400000L);
 372       default :
 373          return 2;
 374    }
 375    return 2;
 376 }
 377 static private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
 378 {
 379    if (((active0 &= old0)) == 0L)
 380       return 2;
 381    try { curChar = input_stream.readChar(); }
 382    catch(java.io.IOException e) {
 383       return 2;
 384    }
 385    switch(curChar)
 386    {
 387       case 68:
 388       case 100:
 389          return jjMoveStringLiteralDfa3_4(active0, 0x400000L);
 390       default :
 391          return 3;
 392    }
 393 }
 394 static private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
 395 {
 396    if (((active0 &= old0)) == 0L)
 397       return 3;
 398    try { curChar = input_stream.readChar(); }
 399    catch(java.io.IOException e) {
 400       return 3;
 401    }
 402    switch(curChar)
 403    {
 404       case 79:
 405       case 111:
 406          if ((active0 & 0x400000L) != 0L)
 407             return jjStopAtPos(3, 22);
 408          break;
 409       default :
 410          return 4;
 411    }
 412    return 4;
 413 }
 414 private static final int jjStopStringLiteralDfa_3(int pos, long active0, long active1, long active2)
 415 {
 416    switch (pos)
 417    {
 418       case 0:
 419          if ((active1 & 0x3000000000L) != 0L)
 420          {
 421             jjmatchedKind = 124;
 422             return 1;
 423          }
 424          return -1;
 425       case 1:
 426          if ((active1 & 0x1000000000L) != 0L)
 427             return 1;
 428          if ((active1 & 0x2000000000L) != 0L)
 429          {
 430             if (jjmatchedPos != 1)
 431             {
 432                jjmatchedKind = 124;
 433                jjmatchedPos = 1;
 434             }
 435             return 1;
 436          }
 437          return -1;
 438       default :
 439          return -1;
 440    }
 441 }
 442 private static final int jjStartNfa_3(int pos, long active0, long active1, long active2)
 443 {
 444    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1, active2), pos + 1);
 445 }
 446 static private final int jjStartNfaWithStates_3(int pos, int kind, int state)
 447 {
 448    jjmatchedKind = kind;
 449    jjmatchedPos = pos;
 450    try { curChar = input_stream.readChar(); }
 451    catch(java.io.IOException e) { return pos + 1; }
 452    return jjMoveNfa_3(state, pos + 1);
 453 }
 454 static private final int jjMoveStringLiteralDfa0_3()
 455 {
 456    switch(curChar)
 457    {
 458       case 9:
 459          return jjStopAtPos(0, 12);
 460       case 10:
 461          return jjStopAtPos(0, 13);
 462       case 12:
 463          return jjStopAtPos(0, 15);
 464       case 13:
 465          return jjStopAtPos(0, 14);
 466       case 32:
 467          return jjStopAtPos(0, 11);
 468       case 33:
 469          jjmatchedKind = 81;
 470          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x28000L);
 471       case 36:
 472          return jjStopAtPos(0, 123);
 473       case 37:
 474          jjmatchedKind = 96;
 475          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x10000000L);
 476       case 38:
 477          jjmatchedKind = 93;
 478          return jjMoveStringLiteralDfa1_3(0x0L, 0x400000L, 0x1000000L);
 479       case 40:
 480          return jjStopAtPos(0, 129);
 481       case 41:
 482          return jjStopAtPos(0, 130);
 483       case 42:
 484          jjmatchedKind = 91;
 485          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x400000L);
 486       case 43:
 487          jjmatchedKind = 89;
 488          return jjMoveStringLiteralDfa1_3(0x0L, 0x800000L, 0x100000L);
 489       case 44:
 490          return jjStopAtPos(0, 136);
 491       case 45:
 492          jjmatchedKind = 90;
 493          return jjMoveStringLiteralDfa1_3(0x200000000000L, 0x1000000L, 0x200000L);
 494       case 46:
 495          jjmatchedKind = 137;
 496          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x8000000L);
 497       case 47:
 498          jjmatchedKind = 92;
 499          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x800000L);
 500       case 58:
 501          jjmatchedKind = 84;
 502          return jjMoveStringLiteralDfa1_3(0x400000000000L, 0x0L, 0x0L);
 503       case 59:
 504          return jjStopAtPos(0, 135);
 505       case 60:
 506          jjmatchedKind = 139;
 507          return jjMoveStringLiteralDfa1_3(0x0L, 0x200000000L, 0x40012000L);
 508       case 61:
 509          jjmatchedKind = 147;
 510          return jjMoveStringLiteralDfa1_3(0x800000000000L, 0x0L, 0x41000L);
 511       case 62:
 512          jjmatchedKind = 138;
 513          return jjMoveStringLiteralDfa1_3(0x0L, 0xc00000000L, 0x80004000L);
 514       case 63:
 515          jjmatchedKind = 83;
 516          return jjMoveStringLiteralDfa1_3(0x10L, 0x0L, 0x0L);
 517       case 64:
 518          return jjStopAtPos(0, 80);
 519       case 91:
 520          return jjStopAtPos(0, 133);
 521       case 93:
 522          return jjStopAtPos(0, 134);
 523       case 94:
 524          jjmatchedKind = 95;
 525          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x4000000L);
 526       case 65:
 527       case 97:
 528          return jjMoveStringLiteralDfa1_3(0x0L, 0x2000000000L, 0x0L);
 529       case 79:
 530       case 111:
 531          return jjMoveStringLiteralDfa1_3(0x0L, 0x1000000000L, 0x0L);
 532       case 123:
 533          return jjStopAtPos(0, 131);
 534       case 124:
 535          jjmatchedKind = 94;
 536          return jjMoveStringLiteralDfa1_3(0x0L, 0x200000L, 0x2000000L);
 537       case 125:
 538          return jjStopAtPos(0, 132);
 539       case 126:
 540          jjmatchedKind = 82;
 541          return jjMoveStringLiteralDfa1_3(0x0L, 0x0L, 0x20000000L);
 542       default :
 543          return jjMoveNfa_3(0, 0);
 544    }
 545 }
 546 static private final int jjMoveStringLiteralDfa1_3(long active0, long active1, long active2)
 547 {
 548    try { curChar = input_stream.readChar(); }
 549    catch(java.io.IOException e) {
 550       jjStopStringLiteralDfa_3(0, active0, active1, active2);
 551       return 1;
 552    }
 553    switch(curChar)
 554    {
 555       case 38:
 556          if ((active1 & 0x400000L) != 0L)
 557             return jjStopAtPos(1, 86);
 558          break;
 559       case 43:
 560          if ((active1 & 0x800000L) != 0L)
 561             return jjStopAtPos(1, 87);
 562          break;
 563       case 45:
 564          if ((active1 & 0x1000000L) != 0L)
 565             return jjStopAtPos(1, 88);
 566          break;
 567       case 58:
 568          if ((active0 & 0x400000000000L) != 0L)
 569             return jjStopAtPos(1, 46);
 570          break;
 571       case 60:
 572          if ((active1 & 0x200000000L) != 0L)
 573          {
 574             jjmatchedKind = 97;
 575             jjmatchedPos = 1;
 576          }
 577          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0x40000000L);
 578       case 61:
 579          if ((active2 & 0x1000L) != 0L)
 580          {
 581             jjmatchedKind = 140;
 582             jjmatchedPos = 1;
 583          }
 584          else if ((active2 & 0x2000L) != 0L)
 585             return jjStopAtPos(1, 141);
 586          else if ((active2 & 0x4000L) != 0L)
 587             return jjStopAtPos(1, 142);
 588          else if ((active2 & 0x8000L) != 0L)
 589          {
 590             jjmatchedKind = 143;
 591             jjmatchedPos = 1;
 592          }
 593          else if ((active2 & 0x100000L) != 0L)
 594             return jjStopAtPos(1, 148);
 595          else if ((active2 & 0x200000L) != 0L)
 596             return jjStopAtPos(1, 149);
 597          else if ((active2 & 0x400000L) != 0L)
 598             return jjStopAtPos(1, 150);
 599          else if ((active2 & 0x800000L) != 0L)
 600             return jjStopAtPos(1, 151);
 601          else if ((active2 & 0x1000000L) != 0L)
 602             return jjStopAtPos(1, 152);
 603          else if ((active2 & 0x2000000L) != 0L)
 604             return jjStopAtPos(1, 153);
 605          else if ((active2 & 0x4000000L) != 0L)
 606             return jjStopAtPos(1, 154);
 607          else if ((active2 & 0x8000000L) != 0L)
 608             return jjStopAtPos(1, 155);
 609          else if ((active2 & 0x10000000L) != 0L)
 610             return jjStopAtPos(1, 156);
 611          else if ((active2 & 0x20000000L) != 0L)
 612             return jjStopAtPos(1, 157);
 613          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0L, active2, 0x60000L);
 614       case 62:
 615          if ((active0 & 0x10L) != 0L)
 616             return jjStopAtPos(1, 4);
 617          else if ((active0 & 0x200000000000L) != 0L)
 618             return jjStopAtPos(1, 45);
 619          else if ((active0 & 0x800000000000L) != 0L)
 620             return jjStopAtPos(1, 47);
 621          else if ((active1 & 0x400000000L) != 0L)
 622          {
 623             jjmatchedKind = 98;
 624             jjmatchedPos = 1;
 625          }
 626          else if ((active2 & 0x10000L) != 0L)
 627             return jjStopAtPos(1, 144);
 628          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0x800000000L, active2, 0x80000000L);
 629       case 78:
 630       case 110:
 631          return jjMoveStringLiteralDfa2_3(active0, 0L, active1, 0x2000000000L, active2, 0L);
 632       case 82:
 633       case 114:
 634          if ((active1 & 0x1000000000L) != 0L)
 635             return jjStartNfaWithStates_3(1, 100, 1);
 636          break;
 637       case 124:
 638          if ((active1 & 0x200000L) != 0L)
 639             return jjStopAtPos(1, 85);
 640          break;
 641       default :
 642          break;
 643    }
 644    return jjStartNfa_3(0, active0, active1, active2);
 645 }
 646 static private final int jjMoveStringLiteralDfa2_3(long old0, long active0, long old1, long active1, long old2, long active2)
 647 {
 648    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
 649       return jjStartNfa_3(0, old0, old1, old2);
 650    try { curChar = input_stream.readChar(); }
 651    catch(java.io.IOException e) {
 652       jjStopStringLiteralDfa_3(1, 0L, active1, active2);
 653       return 2;
 654    }
 655    switch(curChar)
 656    {
 657       case 61:
 658          if ((active2 & 0x20000L) != 0L)
 659             return jjStopAtPos(2, 145);
 660          else if ((active2 & 0x40000L) != 0L)
 661             return jjStopAtPos(2, 146);
 662          else if ((active2 & 0x40000000L) != 0L)
 663             return jjStopAtPos(2, 158);
 664          else if ((active2 & 0x80000000L) != 0L)
 665             return jjStopAtPos(2, 159);
 666          break;
 667       case 62:
 668          if ((active1 & 0x800000000L) != 0L)
 669             return jjStopAtPos(2, 99);
 670          break;
 671       case 68:
 672       case 100:
 673          if ((active1 & 0x2000000000L) != 0L)
 674             return jjStartNfaWithStates_3(2, 101, 1);
 675          break;
 676       default :
 677          break;
 678    }
 679    return jjStartNfa_3(1, 0L, active1, active2);
 680 }
 681 static private final int jjMoveNfa_3(int startState, int curPos)
 682 {
 683    int[] nextStates;
 684    int startsAt = 0;
 685    jjnewStateCnt = 2;
 686    int i = 1;
 687    jjstateSet[0] = startState;
 688    int j, kind = 0x7fffffff;
 689    for (;;)
 690    {
 691       if (++jjround == 0x7fffffff)
 692          ReInitRounds();
 693       if (curChar < 64)
 694       {
 695          long l = 1L << curChar;
 696          MatchLoop: do
 697          {
 698             switch(jjstateSet[--i])
 699             {
 700                case 1:
 701                   if ((0x3ff000000000000L & l) == 0L)
 702                      break;
 703                   kind = 124;
 704                   jjstateSet[jjnewStateCnt++] = 1;
 705                   break;
 706                default : break;
 707             }
 708          } while(i != startsAt);
 709       }
 710       else if (curChar < 128)
 711       {
 712          long l = 1L << (curChar & 077);
 713          MatchLoop: do
 714          {
 715             switch(jjstateSet[--i])
 716             {
 717                case 0:
 718                case 1:
 719                   if ((0x87fffffe87fffffeL & l) == 0L)
 720                      break;
 721                   if (kind > 124)
 722                      kind = 124;
 723                   jjCheckNAdd(1);
 724                   break;
 725                default : break;
 726             }
 727          } while(i != startsAt);
 728       }
 729       else
 730       {
 731          int i2 = (curChar & 0xff) >> 6;
 732          long l2 = 1L << (curChar & 077);
 733          MatchLoop: do
 734          {
 735             switch(jjstateSet[--i])
 736             {
 737                case 0:
 738                case 1:
 739                   if ((jjbitVec0[i2] & l2) == 0L)
 740                      break;
 741                   if (kind > 124)
 742                      kind = 124;
 743                   jjCheckNAdd(1);
 744                   break;
 745                default : break;
 746             }
 747          } while(i != startsAt);
 748       }
 749       if (kind != 0x7fffffff)
 750       {
 751          jjmatchedKind = kind;
 752          jjmatchedPos = curPos;
 753          kind = 0x7fffffff;
 754       }
 755       ++curPos;
 756       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
 757          return curPos;
 758       try { curChar = input_stream.readChar(); }
 759       catch(java.io.IOException e) { return curPos; }
 760    }
 761 }
 762 private static final int jjStopStringLiteralDfa_6(int pos, long active0, long active1)
 763 {
 764    switch (pos)
 765    {
 766       default :
 767          return -1;
 768    }
 769 }
 770 private static final int jjStartNfa_6(int pos, long active0, long active1)
 771 {
 772    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1), pos + 1);
 773 }
 774 static private final int jjStartNfaWithStates_6(int pos, int kind, int state)
 775 {
 776    jjmatchedKind = kind;
 777    jjmatchedPos = pos;
 778    try { curChar = input_stream.readChar(); }
 779    catch(java.io.IOException e) { return pos + 1; }
 780    return jjMoveNfa_6(state, pos + 1);
 781 }
 782 static private final int jjMoveStringLiteralDfa0_6()
 783 {
 784    switch(curChar)
 785    {
 786       case 34:
 787          return jjStopAtPos(0, 114);
 788       case 36:
 789          return jjStopAtPos(0, 113);
 790       case 123:
 791          return jjStopAtPos(0, 116);
 792       default :
 793          return jjMoveNfa_6(0, 0);
 794    }
 795 }
 796 static private final int jjMoveNfa_6(int startState, int curPos)
 797 {
 798    int[] nextStates;
 799    int startsAt = 0;
 800    jjnewStateCnt = 2;
 801    int i = 1;
 802    jjstateSet[0] = startState;
 803    int j, kind = 0x7fffffff;
 804    for (;;)
 805    {
 806       if (++jjround == 0x7fffffff)
 807          ReInitRounds();
 808       if (curChar < 64)
 809       {
 810          long l = 1L << curChar;
 811          MatchLoop: do
 812          {
 813             switch(jjstateSet[--i])
 814             {
 815                case 1:
 816                   kind = 111;
 817                   break;
 818                default : break;
 819             }
 820          } while(i != startsAt);
 821       }
 822       else if (curChar < 128)
 823       {
 824          long l = 1L << (curChar & 077);
 825          MatchLoop: do
 826          {
 827             switch(jjstateSet[--i])
 828             {
 829                case 0:
 830                   if (curChar == 92)
 831                      jjstateSet[jjnewStateCnt++] = 1;
 832                   break;
 833                case 1:
 834                   if (kind > 111)
 835                      kind = 111;
 836                   break;
 837                default : break;
 838             }
 839          } while(i != startsAt);
 840       }
 841       else
 842       {
 843          int i2 = (curChar & 0xff) >> 6;
 844          long l2 = 1L << (curChar & 077);
 845          MatchLoop: do
 846          {
 847             switch(jjstateSet[--i])
 848             {
 849                case 1:
 850                   if ((jjbitVec0[i2] & l2) != 0L && kind > 111)
 851                      kind = 111;
 852                   break;
 853                default : break;
 854             }
 855          } while(i != startsAt);
 856       }
 857       if (kind != 0x7fffffff)
 858       {
 859          jjmatchedKind = kind;
 860          jjmatchedPos = curPos;
 861          kind = 0x7fffffff;
 862       }
 863       ++curPos;
 864       if ((i = jjnewStateCnt) == (startsAt = 2 - (jjnewStateCnt = startsAt)))
 865          return curPos;
 866       try { curChar = input_stream.readChar(); }
 867       catch(java.io.IOException e) { return curPos; }
 868    }
 869 }
 870 private static final int jjStopStringLiteralDfa_2(int pos, long active0)
 871 {
 872    switch (pos)
 873    {
 874       default :
 875          return -1;
 876    }
 877 }
 878 private static final int jjStartNfa_2(int pos, long active0)
 879 {
 880    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
 881 }
 882 static private final int jjStartNfaWithStates_2(int pos, int kind, int state)
 883 {
 884    jjmatchedKind = kind;
 885    jjmatchedPos = pos;
 886    try { curChar = input_stream.readChar(); }
 887    catch(java.io.IOException e) { return pos + 1; }
 888    return jjMoveNfa_2(state, pos + 1);
 889 }
 890 static private final int jjMoveStringLiteralDfa0_2()
 891 {
 892    switch(curChar)
 893    {
 894       case 63:
 895          return jjMoveStringLiteralDfa1_2(0x10L);
 896       case 84:
 897       case 116:
 898          return jjMoveStringLiteralDfa1_2(0x400000L);
 899       default :
 900          return jjMoveNfa_2(0, 0);
 901    }
 902 }
 903 static private final int jjMoveStringLiteralDfa1_2(long active0)
 904 {
 905    try { curChar = input_stream.readChar(); }
 906    catch(java.io.IOException e) {
 907       jjStopStringLiteralDfa_2(0, active0);
 908       return 1;
 909    }
 910    switch(curChar)
 911    {
 912       case 62:
 913          if ((active0 & 0x10L) != 0L)
 914             return jjStopAtPos(1, 4);
 915          break;
 916       case 79:
 917       case 111:
 918          return jjMoveStringLiteralDfa2_2(active0, 0x400000L);
 919       default :
 920          break;
 921    }
 922    return jjStartNfa_2(0, active0);
 923 }
 924 static private final int jjMoveStringLiteralDfa2_2(long old0, long active0)
 925 {
 926    if (((active0 &= old0)) == 0L)
 927       return jjStartNfa_2(0, old0);
 928    try { curChar = input_stream.readChar(); }
 929    catch(java.io.IOException e) {
 930       jjStopStringLiteralDfa_2(1, active0);
 931       return 2;
 932    }
 933    switch(curChar)
 934    {
 935       case 68:
 936       case 100:
 937          return jjMoveStringLiteralDfa3_2(active0, 0x400000L);
 938       default :
 939          break;
 940    }
 941    return jjStartNfa_2(1, active0);
 942 }
 943 static private final int jjMoveStringLiteralDfa3_2(long old0, long active0)
 944 {
 945    if (((active0 &= old0)) == 0L)
 946       return jjStartNfa_2(1, old0);
 947    try { curChar = input_stream.readChar(); }
 948    catch(java.io.IOException e) {
 949       jjStopStringLiteralDfa_2(2, active0);
 950       return 3;
 951    }
 952    switch(curChar)
 953    {
 954       case 79:
 955       case 111:
 956          if ((active0 & 0x400000L) != 0L)
 957             return jjStopAtPos(3, 22);
 958          break;
 959       default :
 960          break;
 961    }
 962    return jjStartNfa_2(2, active0);
 963 }
 964 static private final int jjMoveNfa_2(int startState, int curPos)
 965 {
 966    int[] nextStates;
 967    int startsAt = 0;
 968    jjnewStateCnt = 3;
 969    int i = 1;
 970    jjstateSet[0] = startState;
 971    int j, kind = 0x7fffffff;
 972    for (;;)
 973    {
 974       if (++jjround == 0x7fffffff)
 975          ReInitRounds();
 976       if (curChar < 64)
 977       {
 978          long l = 1L << curChar;
 979          MatchLoop: do
 980          {
 981             switch(jjstateSet[--i])
 982             {
 983                case 0:
 984                   if ((0x2400L & l) != 0L)
 985                   {
 986                      if (kind > 20)
 987                         kind = 20;
 988                   }
 989                   if (curChar == 13)
 990                      jjstateSet[jjnewStateCnt++] = 1;
 991                   break;
 992                case 1:
 993                   if (curChar == 10 && kind > 20)
 994                      kind = 20;
 995                   break;
 996                case 2:
 997                   if (curChar == 13)
 998                      jjstateSet[jjnewStateCnt++] = 1;
 999                   break;
1000                default : break;
1001             }
1002          } while(i != startsAt);
1003       }
1004       else if (curChar < 128)
1005       {
1006          long l = 1L << (curChar & 077);
1007          MatchLoop: do
1008          {
1009             switch(jjstateSet[--i])
1010             {
1011                default : break;
1012             }
1013          } while(i != startsAt);
1014       }
1015       else
1016       {
1017          int i2 = (curChar & 0xff) >> 6;
1018          long l2 = 1L << (curChar & 077);
1019          MatchLoop: do
1020          {
1021             switch(jjstateSet[--i])
1022             {
1023                default : break;
1024             }
1025          } while(i != startsAt);
1026       }
1027       if (kind != 0x7fffffff)
1028       {
1029          jjmatchedKind = kind;
1030          jjmatchedPos = curPos;
1031          kind = 0x7fffffff;
1032       }
1033       ++curPos;
1034       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1035          return curPos;
1036       try { curChar = input_stream.readChar(); }
1037       catch(java.io.IOException e) { return curPos; }
1038    }
1039 }
1040 private static final int jjStopStringLiteralDfa_1(int pos, long active0, long active1, long active2)
1041 {
1042    switch (pos)
1043    {
1044       case 0:
1045          if ((active0 & 0xffff1ffff8000000L) != 0L || (active1 & 0x300000ffffL) != 0L)
1046          {
1047             jjmatchedKind = 124;
1048             return 14;
1049          }
1050          if ((active0 & 0x90000L) != 0L || (active1 & 0x10000000L) != 0L || (active2 & 0x800000L) != 0L)
1051             return 2;
1052          if ((active2 & 0x8000200L) != 0L)
1053             return 8;
1054          return -1;
1055       case 1:
1056          if ((active0 & 0x80000L) != 0L)
1057             return 0;
1058          if ((active0 & 0x10000040000000L) != 0L || (active1 & 0x1000001040L) != 0L)
1059             return 14;
1060          if ((active0 & 0xffef1fffb8000000L) != 0L || (active1 & 0x200000efbfL) != 0L)
1061          {
1062             if (jjmatchedPos != 1)
1063             {
1064                jjmatchedKind = 124;
1065                jjmatchedPos = 1;
1066             }
1067             return 14;
1068          }
1069          return -1;
1070       case 2:
1071          if ((active0 & 0x140000020000000L) != 0L || (active1 & 0x200000c020L) != 0L)
1072             return 14;
1073          if ((active0 & 0xfeaf1fff98000000L) != 0L || (active1 & 0x3f9fL) != 0L)
1074          {
1075             if (jjmatchedPos != 2)
1076             {
1077                jjmatchedKind = 124;
1078                jjmatchedPos = 2;
1079             }
1080             return 14;
1081          }
1082          return -1;
1083       case 3:
1084          if ((active0 & 0x9c2e1fd618000000L) != 0L || (active1 & 0xb1bfL) != 0L)
1085          {
1086             if (jjmatchedPos != 3)
1087             {
1088                jjmatchedKind = 124;
1089                jjmatchedPos = 3;
1090             }
1091             return 14;
1092          }
1093          if ((active0 & 0x6281002980000000L) != 0L || (active1 & 0xe00L) != 0L)
1094             return 14;
1095          return -1;
1096       case 4:
1097          if ((active0 & 0x8802001608000000L) != 0L || (active1 & 0x2009L) != 0L)
1098             return 14;
1099          if ((active0 & 0x142c1fc090000000L) != 0L || (active1 & 0x95b6L) != 0L)
1100          {
1101             jjmatchedKind = 124;
1102             jjmatchedPos = 4;
1103             return 14;
1104          }
1105          return -1;
1106       case 5:
1107          if ((active0 & 0x14001c0080000000L) != 0L || (active1 & 0x1190L) != 0L)
1108             return 14;
1109          if ((active0 & 0x2c03c010000000L) != 0L || (active1 & 0x8426L) != 0L)
1110          {
1111             jjmatchedKind = 124;
1112             jjmatchedPos = 5;
1113             return 14;
1114          }
1115          return -1;
1116       case 6:
1117          if ((active0 & 0x2803c000000000L) != 0L || (active1 & 0x8420L) != 0L)
1118             return 14;
1119          if ((active0 & 0x4000010000000L) != 0L || (active1 & 0x6L) != 0L)
1120          {
1121             if (jjmatchedPos != 6)
1122             {
1123                jjmatchedKind = 124;
1124                jjmatchedPos = 6;
1125             }
1126             return 14;
1127          }
1128          return -1;
1129       case 7:
1130          if ((active0 & 0x30000000000L) != 0L || (active1 & 0x4L) != 0L)
1131          {
1132             jjmatchedKind = 124;
1133             jjmatchedPos = 7;
1134             return 14;
1135          }
1136          if ((active0 & 0x4000010000000L) != 0L || (active1 & 0x2L) != 0L)
1137             return 14;
1138          return -1;
1139       case 8:
1140          if ((active1 & 0x4L) != 0L)
1141             return 14;
1142          if ((active0 & 0x30000000000L) != 0L)
1143          {
1144             jjmatchedKind = 124;
1145             jjmatchedPos = 8;
1146             return 14;
1147          }
1148          return -1;
1149       case 9:
1150          if ((active0 & 0x30000000000L) != 0L)
1151          {
1152             jjmatchedKind = 124;
1153             jjmatchedPos = 9;
1154             return 14;
1155          }
1156          return -1;
1157       case 10:
1158          if ((active0 & 0x30000000000L) != 0L)
1159          {
1160             jjmatchedKind = 124;
1161             jjmatchedPos = 10;
1162             return 14;
1163          }
1164          return -1;
1165       default :
1166          return -1;
1167    }
1168 }
1169 private static final int jjStartNfa_1(int pos, long active0, long active1, long active2)
1170 {
1171    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1, active2), pos + 1);
1172 }
1173 static private final int jjStartNfaWithStates_1(int pos, int kind, int state)
1174 {
1175    jjmatchedKind = kind;
1176    jjmatchedPos = pos;
1177    try { curChar = input_stream.readChar(); }
1178    catch(java.io.IOException e) { return pos + 1; }
1179    return jjMoveNfa_1(state, pos + 1);
1180 }
1181 static private final int jjMoveStringLiteralDfa0_1()
1182 {
1183    switch(curChar)
1184    {
1185       case 33:
1186          jjmatchedKind = 81;
1187          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x28000L);
1188       case 34:
1189          return jjStopAtPos(0, 112);
1190       case 35:
1191          return jjStopAtPos(0, 17);
1192       case 36:
1193          return jjStopAtPos(0, 123);
1194       case 37:
1195          jjmatchedKind = 96;
1196          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x10000000L);
1197       case 38:
1198          jjmatchedKind = 93;
1199          return jjMoveStringLiteralDfa1_1(0x0L, 0x400000L, 0x1000000L);
1200       case 40:
1201          return jjStopAtPos(0, 129);
1202       case 41:
1203          return jjStopAtPos(0, 130);
1204       case 42:
1205          jjmatchedKind = 91;
1206          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x400000L);
1207       case 43:
1208          jjmatchedKind = 89;
1209          return jjMoveStringLiteralDfa1_1(0x0L, 0x800000L, 0x100000L);
1210       case 44:
1211          return jjStopAtPos(0, 136);
1212       case 45:
1213          jjmatchedKind = 90;
1214          return jjMoveStringLiteralDfa1_1(0x200000000000L, 0x1000000L, 0x200000L);
1215       case 46:
1216          jjmatchedKind = 137;
1217          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x8000000L);
1218       case 47:
1219          jjmatchedKind = 92;
1220          return jjMoveStringLiteralDfa1_1(0x90000L, 0x0L, 0x800000L);
1221       case 58:
1222          jjmatchedKind = 84;
1223          return jjMoveStringLiteralDfa1_1(0x400000000000L, 0x0L, 0x0L);
1224       case 59:
1225          return jjStopAtPos(0, 135);
1226       case 60:
1227          jjmatchedKind = 139;
1228          return jjMoveStringLiteralDfa1_1(0x0L, 0x200000000L, 0x40012000L);
1229       case 61:
1230          jjmatchedKind = 147;
1231          return jjMoveStringLiteralDfa1_1(0x800000000000L, 0x0L, 0x41000L);
1232       case 62:
1233          jjmatchedKind = 138;
1234          return jjMoveStringLiteralDfa1_1(0x0L, 0xc00000000L, 0x80004000L);
1235       case 63:
1236          jjmatchedKind = 83;
1237          return jjMoveStringLiteralDfa1_1(0x10L, 0x0L, 0x0L);
1238       case 64:
1239          return jjStopAtPos(0, 80);
1240       case 91:
1241          return jjStopAtPos(0, 133);
1242       case 93:
1243          return jjStopAtPos(0, 134);
1244       case 94:
1245          jjmatchedKind = 95;
1246          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x4000000L);
1247       case 65:
1248       case 97:
1249          return jjMoveStringLiteralDfa1_1(0x200000000L, 0x2000000040L, 0x0L);
1250       case 66:
1251       case 98:
1252          return jjMoveStringLiteralDfa1_1(0x400000000L, 0x600L, 0x0L);
1253       case 67:
1254       case 99:
1255          return jjMoveStringLiteralDfa1_1(0x7000008000000L, 0x0L, 0x0L);
1256       case 68:
1257       case 100:
1258          return jjMoveStringLiteralDfa1_1(0x18080000000000L, 0x1000L, 0x0L);
1259       case 69:
1260       case 101:
1261          return jjMoveStringLiteralDfa1_1(0x20002180000000L, 0x1eL, 0x0L);
1262       case 70:
1263       case 102:
1264          return jjMoveStringLiteralDfa1_1(0x8040000010000000L, 0x2020L, 0x0L);
1265       case 71:
1266       case 103:
1267          return jjMoveStringLiteralDfa1_1(0x80040000000000L, 0x0L, 0x0L);
1268       case 73:
1269       case 105:
1270          return jjMoveStringLiteralDfa1_1(0x14040000000L, 0xc000L, 0x0L);
1271       case 76:
1272       case 108:
1273          return jjMoveStringLiteralDfa1_1(0x800000000L, 0x0L, 0x0L);
1274       case 78:
1275       case 110:
1276          return jjMoveStringLiteralDfa1_1(0x300000000000000L, 0x0L, 0x0L);
1277       case 79:
1278       case 111:
1279          return jjMoveStringLiteralDfa1_1(0x0L, 0x1000000100L, 0x0L);
1280       case 80:
1281       case 112:
1282          return jjMoveStringLiteralDfa1_1(0x1000000000L, 0x0L, 0x0L);
1283       case 82:
1284       case 114:
1285          return jjMoveStringLiteralDfa1_1(0x400028000000000L, 0x800L, 0x0L);
1286       case 83:
1287       case 115:
1288          return jjMoveStringLiteralDfa1_1(0x1800100000000000L, 0x80L, 0x0L);
1289       case 84:
1290       case 116:
1291          return jjMoveStringLiteralDfa1_1(0x6000000000000000L, 0x0L, 0x0L);
1292       case 86:
1293       case 118:
1294          return jjMoveStringLiteralDfa1_1(0x20000000L, 0x0L, 0x0L);
1295       case 87:
1296       case 119:
1297          return jjMoveStringLiteralDfa1_1(0x0L, 0x1L, 0x0L);
1298       case 123:
1299          return jjStopAtPos(0, 131);
1300       case 124:
1301          jjmatchedKind = 94;
1302          return jjMoveStringLiteralDfa1_1(0x0L, 0x200000L, 0x2000000L);
1303       case 125:
1304          return jjStopAtPos(0, 132);
1305       case 126:
1306          jjmatchedKind = 82;
1307          return jjMoveStringLiteralDfa1_1(0x0L, 0x0L, 0x20000000L);
1308       default :
1309          return jjMoveNfa_1(3, 0);
1310    }
1311 }
1312 static private final int jjMoveStringLiteralDfa1_1(long active0, long active1, long active2)
1313 {
1314    try { curChar = input_stream.readChar(); }
1315    catch(java.io.IOException e) {
1316       jjStopStringLiteralDfa_1(0, active0, active1, active2);
1317       return 1;
1318    }
1319    switch(curChar)
1320    {
1321       case 38:
1322          if ((active1 & 0x400000L) != 0L)
1323             return jjStopAtPos(1, 86);
1324          break;
1325       case 42:
1326          if ((active0 & 0x80000L) != 0L)
1327             return jjStartNfaWithStates_1(1, 19, 0);
1328          break;
1329       case 43:
1330          if ((active1 & 0x800000L) != 0L)
1331             return jjStopAtPos(1, 87);
1332          break;
1333       case 45:
1334          if ((active1 & 0x1000000L) != 0L)
1335             return jjStopAtPos(1, 88);
1336          break;
1337       case 47:
1338          if ((active0 & 0x10000L) != 0L)
1339             return jjStopAtPos(1, 16);
1340          break;
1341       case 58:
1342          if ((active0 & 0x400000000000L) != 0L)
1343             return jjStopAtPos(1, 46);
1344          break;
1345       case 60:
1346          if ((active1 & 0x200000000L) != 0L)
1347          {
1348             jjmatchedKind = 97;
1349             jjmatchedPos = 1;
1350          }
1351          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0x40000000L);
1352       case 61:
1353          if ((active2 & 0x1000L) != 0L)
1354          {
1355             jjmatchedKind = 140;
1356             jjmatchedPos = 1;
1357          }
1358          else if ((active2 & 0x2000L) != 0L)
1359             return jjStopAtPos(1, 141);
1360          else if ((active2 & 0x4000L) != 0L)
1361             return jjStopAtPos(1, 142);
1362          else if ((active2 & 0x8000L) != 0L)
1363          {
1364             jjmatchedKind = 143;
1365             jjmatchedPos = 1;
1366          }
1367          else if ((active2 & 0x100000L) != 0L)
1368             return jjStopAtPos(1, 148);
1369          else if ((active2 & 0x200000L) != 0L)
1370             return jjStopAtPos(1, 149);
1371          else if ((active2 & 0x400000L) != 0L)
1372             return jjStopAtPos(1, 150);
1373          else if ((active2 & 0x800000L) != 0L)
1374             return jjStopAtPos(1, 151);
1375          else if ((active2 & 0x1000000L) != 0L)
1376             return jjStopAtPos(1, 152);
1377          else if ((active2 & 0x2000000L) != 0L)
1378             return jjStopAtPos(1, 153);
1379          else if ((active2 & 0x4000000L) != 0L)
1380             return jjStopAtPos(1, 154);
1381          else if ((active2 & 0x8000000L) != 0L)
1382             return jjStopAtPos(1, 155);
1383          else if ((active2 & 0x10000000L) != 0L)
1384             return jjStopAtPos(1, 156);
1385          else if ((active2 & 0x20000000L) != 0L)
1386             return jjStopAtPos(1, 157);
1387          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0L, active2, 0x60000L);
1388       case 62:
1389          if ((active0 & 0x10L) != 0L)
1390             return jjStopAtPos(1, 4);
1391          else if ((active0 & 0x200000000000L) != 0L)
1392             return jjStopAtPos(1, 45);
1393          else if ((active0 & 0x800000000000L) != 0L)
1394             return jjStopAtPos(1, 47);
1395          else if ((active1 & 0x400000000L) != 0L)
1396          {
1397             jjmatchedKind = 98;
1398             jjmatchedPos = 1;
1399          }
1400          else if ((active2 & 0x10000L) != 0L)
1401             return jjStopAtPos(1, 144);
1402          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x800000000L, active2, 0x80000000L);
1403       case 65:
1404       case 97:
1405          return jjMoveStringLiteralDfa2_1(active0, 0x8001000020000000L, active1, 0L, active2, 0L);
1406       case 66:
1407       case 98:
1408          return jjMoveStringLiteralDfa2_1(active0, 0L, active1, 0x100L, active2, 0L);
1409       case 67:
1410       case 99:
1411          return jjMoveStringLiteralDfa2_1(active0, 0x2000000000L, active1, 0L, active2, 0L);
1412       case 69:
1413       case 101:
1414          return jjMoveStringLiteralDfa2_1(active0, 0x5080a8000000000L, active1, 0x800L, active2, 0L);
1415       case 70:
1416       case 102:
1417          if ((active0 & 0x40000000L) != 0L)
1418             return jjStartNfaWithStates_1(1, 30, 14);
1419          break;
1420       case 72:
1421       case 104:
1422          return jjMoveStringLiteralDfa2_1(active0, 0x2000000000000000L, active1, 0x1L, active2, 0L);
1423       case 73:
1424       case 105:
1425          return jjMoveStringLiteralDfa2_1(active0, 0x800000000L, active1, 0L, active2, 0L);
1426       case 76:
1427       case 108:
1428          return jjMoveStringLiteralDfa2_1(active0, 0x40188000000L, active1, 0x2000L, active2, 0L);
1429       case 78:
1430       case 110:
1431          return jjMoveStringLiteralDfa2_1(active0, 0x14000000000L, active1, 0x200000c01eL, active2, 0L);
1432       case 79:
1433       case 111:
1434          if ((active0 & 0x10000000000000L) != 0L)
1435          {
1436             jjmatchedKind = 52;
1437             jjmatchedPos = 1;
1438          }
1439          return jjMoveStringLiteralDfa2_1(active0, 0xc6000000000000L, active1, 0x1620L, active2, 0L);
1440       case 82:
1441       case 114:
1442          if ((active1 & 0x1000000000L) != 0L)
1443             return jjStartNfaWithStates_1(1, 100, 14);
1444          return jjMoveStringLiteralDfa2_1(active0, 0x4000001600000000L, active1, 0L, active2, 0L);
1445       case 83:
1446       case 115:
1447          if ((active1 & 0x40L) != 0L)
1448             return jjStartNfaWithStates_1(1, 70, 14);
1449          break;
1450       case 84:
1451       case 116:
1452          return jjMoveStringLiteralDfa2_1(active0, 0x100000000000L, active1, 0x80L, active2, 0L);
1453       case 85:
1454       case 117:
1455          return jjMoveStringLiteralDfa2_1(active0, 0xa00000010000000L, active1, 0L, active2, 0L);
1456       case 87:
1457       case 119:
1458          return jjMoveStringLiteralDfa2_1(active0, 0x1000000000000000L, active1, 0L, active2, 0L);
1459       case 88:
1460       case 120:
1461          return jjMoveStringLiteralDfa2_1(active0, 0x20000000000000L, active1, 0L, active2, 0L);
1462       case 124:
1463          if ((active1 & 0x200000L) != 0L)
1464             return jjStopAtPos(1, 85);
1465          break;
1466       default :
1467          break;
1468    }
1469    return jjStartNfa_1(0, active0, active1, active2);
1470 }
1471 static private final int jjMoveStringLiteralDfa2_1(long old0, long active0, long old1, long active1, long old2, long active2)
1472 {
1473    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1474       return jjStartNfa_1(0, old0, old1, old2);
1475    try { curChar = input_stream.readChar(); }
1476    catch(java.io.IOException e) {
1477       jjStopStringLiteralDfa_1(1, active0, active1, active2);
1478       return 2;
1479    }
1480    switch(curChar)
1481    {
1482       case 61:
1483          if ((active2 & 0x20000L) != 0L)
1484             return jjStopAtPos(2, 145);
1485          else if ((active2 & 0x40000L) != 0L)
1486             return jjStopAtPos(2, 146);
1487          else if ((active2 & 0x40000000L) != 0L)
1488             return jjStopAtPos(2, 158);
1489          else if ((active2 & 0x80000000L) != 0L)
1490             return jjStopAtPos(2, 159);
1491          break;
1492       case 62:
1493          if ((active1 & 0x800000000L) != 0L)
1494             return jjStopAtPos(2, 99);
1495          break;
1496       case 65:
1497       case 97:
1498          return jjMoveStringLiteralDfa3_1(active0, 0x100008000000L, active1, 0x800L, active2, 0L);
1499       case 67:
1500       case 99:
1501          return jjMoveStringLiteralDfa3_1(active0, 0x14000000000L, active1, 0L, active2, 0L);
1502       case 68:
1503       case 100:
1504          if ((active1 & 0x2000000000L) != 0L)
1505             return jjStartNfaWithStates_1(2, 101, 14);
1506          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x1eL, active2, 0L);
1507       case 69:
1508       case 101:
1509          return jjMoveStringLiteralDfa3_1(active0, 0x400000000L, active1, 0L, active2, 0L);
1510       case 70:
1511       case 102:
1512          return jjMoveStringLiteralDfa3_1(active0, 0x8080000000000L, active1, 0L, active2, 0L);
1513       case 72:
1514       case 104:
1515          return jjMoveStringLiteralDfa3_1(active0, 0x2000000000L, active1, 0L, active2, 0L);
1516       case 73:
1517       case 105:
1518          return jjMoveStringLiteralDfa3_1(active0, 0x3000001000000000L, active1, 0x1L, active2, 0L);
1519       case 74:
1520       case 106:
1521          return jjMoveStringLiteralDfa3_1(active0, 0L, active1, 0x100L, active2, 0L);
1522       case 76:
1523       case 108:
1524          return jjMoveStringLiteralDfa3_1(active0, 0x8200000000000000L, active1, 0L, active2, 0L);
1525       case 78:
1526       case 110:
1527          return jjMoveStringLiteralDfa3_1(active0, 0x6000010000000L, active1, 0L, active2, 0L);
1528       case 79:
1529       case 111:
1530          return jjMoveStringLiteralDfa3_1(active0, 0x40000000000L, active1, 0x2600L, active2, 0L);
1531       case 80:
1532       case 112:
1533          return jjMoveStringLiteralDfa3_1(active0, 0x800000000000000L, active1, 0L, active2, 0L);
1534       case 81:
1535       case 113:
1536          return jjMoveStringLiteralDfa3_1(active0, 0x28000000000L, active1, 0L, active2, 0L);
1537       case 82:
1538       case 114:
1539          if ((active0 & 0x20000000L) != 0L)
1540             return jjStartNfaWithStates_1(2, 29, 14);
1541          else if ((active0 & 0x40000000000000L) != 0L)
1542          {
1543             jjmatchedKind = 54;
1544             jjmatchedPos = 2;
1545          }
1546          return jjMoveStringLiteralDfa3_1(active0, 0x200000000L, active1, 0xa0L, active2, 0L);
1547       case 83:
1548       case 115:
1549          return jjMoveStringLiteralDfa3_1(active0, 0x1000980000000L, active1, 0L, active2, 0L);
1550       case 84:
1551       case 116:
1552          if ((active1 & 0x4000L) != 0L)
1553          {
1554             jjmatchedKind = 78;
1555             jjmatchedPos = 2;
1556          }
1557          return jjMoveStringLiteralDfa3_1(active0, 0x4a0000000000000L, active1, 0x8000L, active2, 0L);
1558       case 85:
1559       case 117:
1560          return jjMoveStringLiteralDfa3_1(active0, 0x4000000000000000L, active1, 0x1000L, active2, 0L);
1561       case 87:
1562       case 119:
1563          if ((active0 & 0x100000000000000L) != 0L)
1564             return jjStartNfaWithStates_1(2, 56, 14);
1565          break;
1566       default :
1567          break;
1568    }
1569    return jjStartNfa_1(1, active0, active1, active2);
1570 }
1571 static private final int jjMoveStringLiteralDfa3_1(long old0, long active0, long old1, long active1, long old2, long active2)
1572 {
1573    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1574       return jjStartNfa_1(1, old0, old1, old2);
1575    try { curChar = input_stream.readChar(); }
1576    catch(java.io.IOException e) {
1577       jjStopStringLiteralDfa_1(2, active0, active1, 0L);
1578       return 3;
1579    }
1580    switch(curChar)
1581    {
1582       case 65:
1583       case 97:
1584          return jjMoveStringLiteralDfa4_1(active0, 0x8000600000000L, active1, 0x2000L);
1585       case 66:
1586       case 98:
1587          return jjMoveStringLiteralDfa4_1(active0, 0x40000000000L, active1, 0x1000L);
1588       case 67:
1589       case 99:
1590          return jjMoveStringLiteralDfa4_1(active0, 0x10000000L, active1, 0L);
1591       case 69:
1592       case 101:
1593          if ((active0 & 0x100000000L) != 0L)
1594          {
1595             jjmatchedKind = 32;
1596             jjmatchedPos = 3;
1597          }
1598          else if ((active0 & 0x1000000000000L) != 0L)
1599             return jjStartNfaWithStates_1(3, 48, 14);
1600          else if ((active0 & 0x4000000000000000L) != 0L)
1601             return jjStartNfaWithStates_1(3, 62, 14);
1602          return jjMoveStringLiteralDfa4_1(active0, 0x820000080000000L, active1, 0x8120L);
1603       case 70:
1604       case 102:
1605          return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x10L);
1606       case 73:
1607       case 105:
1608          return jjMoveStringLiteralDfa4_1(active0, 0x80000000000L, active1, 0x88L);
1609       case 76:
1610       case 108:
1611          if ((active0 & 0x200000000000000L) != 0L)
1612             return jjStartNfaWithStates_1(3, 57, 14);
1613          else if ((active1 & 0x200L) != 0L)
1614          {
1615             jjmatchedKind = 73;
1616             jjmatchedPos = 3;
1617          }
1618          else if ((active1 & 0x800L) != 0L)
1619             return jjStartNfaWithStates_1(3, 75, 14);
1620          return jjMoveStringLiteralDfa4_1(active0, 0x14000000000L, active1, 0x401L);
1621       case 78:
1622       case 110:
1623          return jjMoveStringLiteralDfa4_1(active0, 0x1000000000L, active1, 0L);
1624       case 79:
1625       case 111:
1626          if ((active0 & 0x2000000000L) != 0L)
1627             return jjStartNfaWithStates_1(3, 37, 14);
1628          else if ((active0 & 0x80000000000000L) != 0L)
1629             return jjStartNfaWithStates_1(3, 55, 14);
1630          break;
1631       case 83:
1632       case 115:
1633          if ((active0 & 0x2000000000000000L) != 0L)
1634             return jjStartNfaWithStates_1(3, 61, 14);
1635          return jjMoveStringLiteralDfa4_1(active0, 0x8002000008000000L, active1, 0x4L);
1636       case 84:
1637       case 116:
1638          if ((active0 & 0x800000000L) != 0L)
1639             return jjStartNfaWithStates_1(3, 35, 14);
1640          return jjMoveStringLiteralDfa4_1(active0, 0x1004100000000000L, active1, 0L);
1641       case 85:
1642       case 117:
1643          return jjMoveStringLiteralDfa4_1(active0, 0x400028000000000L, active1, 0L);
1644       case 87:
1645       case 119:
1646          return jjMoveStringLiteralDfa4_1(active0, 0L, active1, 0x2L);
1647       default :
1648          break;
1649    }
1650    return jjStartNfa_1(2, active0, active1, 0L);
1651 }
1652 static private final int jjMoveStringLiteralDfa4_1(long old0, long active0, long old1, long active1)
1653 {
1654    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1655       return jjStartNfa_1(2, old0, old1, 0L);
1656    try { curChar = input_stream.readChar(); }
1657    catch(java.io.IOException e) {
1658       jjStopStringLiteralDfa_1(3, active0, active1, 0L);
1659       return 4;
1660    }
1661    switch(curChar)
1662    {
1663       case 65:
1664       case 97:
1665          return jjMoveStringLiteralDfa5_1(active0, 0x40000000000L, active1, 0x20L);
1666       case 67:
1667       case 99:
1668          return jjMoveStringLiteralDfa5_1(active0, 0x1000000000000000L, active1, 0x100L);
1669       case 69:
1670       case 101:
1671          if ((active0 & 0x8000000000000000L) != 0L)
1672             return jjStartNfaWithStates_1(4, 63, 14);
1673          else if ((active1 & 0x1L) != 0L)
1674             return jjStartNfaWithStates_1(4, 64, 14);
1675          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x400L);
1676       case 70:
1677       case 102:
1678          if ((active1 & 0x8L) != 0L)
1679             return jjStartNfaWithStates_1(4, 67, 14);
1680          break;
1681       case 71:
1682       case 103:
1683          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x8000L);
1684       case 72:
1685       case 104:
1686          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x2L);
1687       case 73:
1688       case 105:
1689          return jjMoveStringLiteralDfa5_1(active0, 0x4128080000000L, active1, 0L);
1690       case 75:
1691       case 107:
1692          if ((active0 & 0x400000000L) != 0L)
1693             return jjStartNfaWithStates_1(4, 34, 14);
1694          break;
1695       case 76:
1696       case 108:
1697          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x1000L);
1698       case 78:
1699       case 110:
1700          return jjMoveStringLiteralDfa5_1(active0, 0x20080000000000L, active1, 0x80L);
1701       case 79:
1702       case 111:
1703          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x10L);
1704       case 82:
1705       case 114:
1706          if ((active0 & 0x800000000000000L) != 0L)
1707             return jjStartNfaWithStates_1(4, 59, 14);
1708          return jjMoveStringLiteralDfa5_1(active0, 0x400000000000000L, active1, 0L);
1709       case 83:
1710       case 115:
1711          if ((active0 & 0x8000000L) != 0L)
1712             return jjStartNfaWithStates_1(4, 27, 14);
1713          break;
1714       case 84:
1715       case 116:
1716          if ((active0 & 0x1000000000L) != 0L)
1717             return jjStartNfaWithStates_1(4, 36, 14);
1718          else if ((active0 & 0x2000000000000L) != 0L)
1719             return jjStartNfaWithStates_1(4, 49, 14);
1720          else if ((active1 & 0x2000L) != 0L)
1721             return jjStartNfaWithStates_1(4, 77, 14);
1722          return jjMoveStringLiteralDfa5_1(active0, 0x10000000L, active1, 0L);
1723       case 85:
1724       case 117:
1725          return jjMoveStringLiteralDfa5_1(active0, 0x8014000000000L, active1, 0L);
1726       case 87:
1727       case 119:
1728          return jjMoveStringLiteralDfa5_1(active0, 0L, active1, 0x4L);
1729       case 89:
1730       case 121:
1731          if ((active0 & 0x200000000L) != 0L)
1732             return jjStartNfaWithStates_1(4, 33, 14);
1733          break;
1734       default :
1735          break;
1736    }
1737    return jjStartNfa_1(3, active0, active1, 0L);
1738 }
1739 static private final int jjMoveStringLiteralDfa5_1(long old0, long active0, long old1, long active1)
1740 {
1741    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1742       return jjStartNfa_1(3, old0, old1, 0L);
1743    try { curChar = input_stream.readChar(); }
1744    catch(java.io.IOException e) {
1745       jjStopStringLiteralDfa_1(4, active0, active1, 0L);
1746       return 5;
1747    }
1748    switch(curChar)
1749    {
1750       case 65:
1751       case 97:
1752          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x400L);
1753       case 67:
1754       case 99:
1755          if ((active0 & 0x100000000000L) != 0L)
1756             return jjStartNfaWithStates_1(5, 44, 14);
1757          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x20L);
1758       case 68:
1759       case 100:
1760          return jjMoveStringLiteralDfa6_1(active0, 0x20014000000000L, active1, 0L);
1761       case 69:
1762       case 101:
1763          if ((active0 & 0x80000000000L) != 0L)
1764             return jjStartNfaWithStates_1(5, 43, 14);
1765          else if ((active1 & 0x1000L) != 0L)
1766             return jjStartNfaWithStates_1(5, 76, 14);
1767          return jjMoveStringLiteralDfa6_1(active0, 0L, active1, 0x8000L);
1768       case 70:
1769       case 102:
1770          if ((active0 & 0x80000000L) != 0L)
1771             return jjStartNfaWithStates_1(5, 31, 14);
1772          break;
1773       case 71:
1774       case 103:
1775          if ((active1 & 0x80L) != 0L)
1776             return jjStartNfaWithStates_1(5, 71, 14);
1777          break;
1778       case 72:
1779       case 104:
1780          if ((active0 & 0x1000000000000000L) != 0L)
1781             return jjStartNfaWithStates_1(5, 60, 14);
1782          break;
1783       case 73:
1784       case 105:
1785          return jjMoveStringLiteralDfa6_1(active0, 0x10000000L, active1, 0x6L);
1786       case 76:
1787       case 108:
1788          if ((active0 & 0x40000000000L) != 0L)
1789             return jjStartNfaWithStates_1(5, 42, 14);
1790          return jjMoveStringLiteralDfa6_1(active0, 0x8000000000000L, active1, 0L);
1791       case 78:
1792       case 110:
1793          if ((active0 & 0x400000000000000L) != 0L)
1794             return jjStartNfaWithStates_1(5, 58, 14);
1795          return jjMoveStringLiteralDfa6_1(active0, 0x4000000000000L, active1, 0L);
1796       case 82:
1797       case 114:
1798          if ((active1 & 0x10L) != 0L)
1799             return jjStartNfaWithStates_1(5, 68, 14);
1800          return jjMoveStringLiteralDfa6_1(active0, 0x28000000000L, active1, 0L);
1801       case 84:
1802       case 116:
1803          if ((active1 & 0x100L) != 0L)
1804             return jjStartNfaWithStates_1(5, 72, 14);
1805          break;
1806       default :
1807          break;
1808    }
1809    return jjStartNfa_1(4, active0, active1, 0L);
1810 }
1811 static private final int jjMoveStringLiteralDfa6_1(long old0, long active0, long old1, long active1)
1812 {
1813    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1814       return jjStartNfa_1(4, old0, old1, 0L);
1815    try { curChar = input_stream.readChar(); }
1816    catch(java.io.IOException e) {
1817       jjStopStringLiteralDfa_1(5, active0, active1, 0L);
1818       return 6;
1819    }
1820    switch(curChar)
1821    {
1822       case 69:
1823       case 101:
1824          if ((active0 & 0x4000000000L) != 0L)
1825          {
1826             jjmatchedKind = 38;
1827             jjmatchedPos = 6;
1828          }
1829          else if ((active0 & 0x8000000000L) != 0L)
1830          {
1831             jjmatchedKind = 39;
1832             jjmatchedPos = 6;
1833          }
1834          return jjMoveStringLiteralDfa7_1(active0, 0x30000000000L, active1, 0L);
1835       case 72:
1836       case 104:
1837          if ((active1 & 0x20L) != 0L)
1838             return jjStartNfaWithStates_1(6, 69, 14);
1839          break;
1840       case 76:
1841       case 108:
1842          return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x2L);
1843       case 78:
1844       case 110:
1845          if ((active1 & 0x400L) != 0L)
1846             return jjStartNfaWithStates_1(6, 74, 14);
1847          break;
1848       case 79:
1849       case 111:
1850          return jjMoveStringLiteralDfa7_1(active0, 0x10000000L, active1, 0L);
1851       case 82:
1852       case 114:
1853          if ((active1 & 0x8000L) != 0L)
1854             return jjStartNfaWithStates_1(6, 79, 14);
1855          break;
1856       case 83:
1857       case 115:
1858          if ((active0 & 0x20000000000000L) != 0L)
1859             return jjStartNfaWithStates_1(6, 53, 14);
1860          break;
1861       case 84:
1862       case 116:
1863          if ((active0 & 0x8000000000000L) != 0L)
1864             return jjStartNfaWithStates_1(6, 51, 14);
1865          return jjMoveStringLiteralDfa7_1(active0, 0L, active1, 0x4L);
1866       case 85:
1867       case 117:
1868          return jjMoveStringLiteralDfa7_1(active0, 0x4000000000000L, active1, 0L);
1869       default :
1870          break;
1871    }
1872    return jjStartNfa_1(5, active0, active1, 0L);
1873 }
1874 static private final int jjMoveStringLiteralDfa7_1(long old0, long active0, long old1, long active1)
1875 {
1876    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1877       return jjStartNfa_1(5, old0, old1, 0L);
1878    try { curChar = input_stream.readChar(); }
1879    catch(java.io.IOException e) {
1880       jjStopStringLiteralDfa_1(6, active0, active1, 0L);
1881       return 7;
1882    }
1883    switch(curChar)
1884    {
1885       case 95:
1886          return jjMoveStringLiteralDfa8_1(active0, 0x30000000000L, active1, 0L);
1887       case 67:
1888       case 99:
1889          return jjMoveStringLiteralDfa8_1(active0, 0L, active1, 0x4L);
1890       case 69:
1891       case 101:
1892          if ((active0 & 0x4000000000000L) != 0L)
1893             return jjStartNfaWithStates_1(7, 50, 14);
1894          else if ((active1 & 0x2L) != 0L)
1895             return jjStartNfaWithStates_1(7, 65, 14);
1896          break;
1897       case 78:
1898       case 110:
1899          if ((active0 & 0x10000000L) != 0L)
1900             return jjStartNfaWithStates_1(7, 28, 14);
1901          break;
1902       default :
1903          break;
1904    }
1905    return jjStartNfa_1(6, active0, active1, 0L);
1906 }
1907 static private final int jjMoveStringLiteralDfa8_1(long old0, long active0, long old1, long active1)
1908 {
1909    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1910       return jjStartNfa_1(6, old0, old1, 0L);
1911    try { curChar = input_stream.readChar(); }
1912    catch(java.io.IOException e) {
1913       jjStopStringLiteralDfa_1(7, active0, active1, 0L);
1914       return 8;
1915    }
1916    switch(curChar)
1917    {
1918       case 72:
1919       case 104:
1920          if ((active1 & 0x4L) != 0L)
1921             return jjStartNfaWithStates_1(8, 66, 14);
1922          break;
1923       case 79:
1924       case 111:
1925          return jjMoveStringLiteralDfa9_1(active0, 0x30000000000L, active1, 0L);
1926       default :
1927          break;
1928    }
1929    return jjStartNfa_1(7, active0, active1, 0L);
1930 }
1931 static private final int jjMoveStringLiteralDfa9_1(long old0, long active0, long old1, long active1)
1932 {
1933    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1934       return jjStartNfa_1(7, old0, old1, 0L);
1935    try { curChar = input_stream.readChar(); }
1936    catch(java.io.IOException e) {
1937       jjStopStringLiteralDfa_1(8, active0, 0L, 0L);
1938       return 9;
1939    }
1940    switch(curChar)
1941    {
1942       case 78:
1943       case 110:
1944          return jjMoveStringLiteralDfa10_1(active0, 0x30000000000L);
1945       default :
1946          break;
1947    }
1948    return jjStartNfa_1(8, active0, 0L, 0L);
1949 }
1950 static private final int jjMoveStringLiteralDfa10_1(long old0, long active0)
1951 {
1952    if (((active0 &= old0)) == 0L)
1953       return jjStartNfa_1(8, old0, 0L, 0L);
1954    try { curChar = input_stream.readChar(); }
1955    catch(java.io.IOException e) {
1956       jjStopStringLiteralDfa_1(9, active0, 0L, 0L);
1957       return 10;
1958    }
1959    switch(curChar)
1960    {
1961       case 67:
1962       case 99:
1963          return jjMoveStringLiteralDfa11_1(active0, 0x30000000000L);
1964       default :
1965          break;
1966    }
1967    return jjStartNfa_1(9, active0, 0L, 0L);
1968 }
1969 static private final int jjMoveStringLiteralDfa11_1(long old0, long active0)
1970 {
1971    if (((active0 &= old0)) == 0L)
1972       return jjStartNfa_1(9, old0, 0L, 0L);
1973    try { curChar = input_stream.readChar(); }
1974    catch(java.io.IOException e) {
1975       jjStopStringLiteralDfa_1(10, active0, 0L, 0L);
1976       return 11;
1977    }
1978    switch(curChar)
1979    {
1980       case 69:
1981       case 101:
1982          if ((active0 & 0x10000000000L) != 0L)
1983             return jjStartNfaWithStates_1(11, 40, 14);
1984          else if ((active0 & 0x20000000000L) != 0L)
1985             return jjStartNfaWithStates_1(11, 41, 14);
1986          break;
1987       default :
1988          break;
1989    }
1990    return jjStartNfa_1(10, active0, 0L, 0L);
1991 }
1992 static private final int jjMoveNfa_1(int startState, int curPos)
1993 {
1994    int[] nextStates;
1995    int startsAt = 0;
1996    jjnewStateCnt = 52;
1997    int i = 1;
1998    jjstateSet[0] = startState;
1999    int j, kind = 0x7fffffff;
2000    for (;;)
2001    {
2002       if (++jjround == 0x7fffffff)
2003          ReInitRounds();
2004       if (curChar < 64)
2005       {
2006          long l = 1L << curChar;
2007          MatchLoop: do
2008          {
2009             switch(jjstateSet[--i])
2010             {
2011                case 3:
2012                   if ((0x3ff000000000000L & l) != 0L)
2013                      jjCheckNAddStates(0, 6);
2014                   else if (curChar == 39)
2015                      jjCheckNAddStates(7, 12);
2016                   else if (curChar == 46)
2017                      jjCheckNAdd(8);
2018                   else if (curChar == 47)
2019                      jjstateSet[jjnewStateCnt++] = 2;
2020                   if ((0x3fe000000000000L & l) != 0L)
2021                   {
2022                      if (kind > 102)
2023                         kind = 102;
2024                      jjCheckNAddTwoStates(5, 6);
2025                   }
2026                   else if (curChar == 48)
2027                   {
2028                      if (kind > 102)
2029                         kind = 102;
2030                      jjCheckNAddStates(13, 15);
2031                   }
2032                   break;
2033                case 0:
2034                   if (curChar == 42)
2035                      jjstateSet[jjnewStateCnt++] = 1;
2036                   break;
2037                case 1:
2038                   if ((0xffff7fffffffffffL & l) != 0L && kind > 18)
2039                      kind = 18;
2040                   break;
2041                case 2:
2042                   if (curChar == 42)
2043                      jjstateSet[jjnewStateCnt++] = 0;
2044                   break;
2045                case 4:
2046                   if ((0x3fe000000000000L & l) == 0L)
2047                      break;
2048                   if (kind > 102)
2049                      kind = 102;
2050                   jjCheckNAddTwoStates(5, 6);
2051                   break;
2052                case 5:
2053                   if ((0x3ff000000000000L & l) == 0L)
2054                      break;
2055                   if (kind > 102)
2056                      kind = 102;
2057                   jjCheckNAddTwoStates(5, 6);
2058                   break;
2059                case 7:
2060                   if (curChar == 46)
2061                      jjCheckNAdd(8);
2062                   break;
2063                case 8:
2064                   if ((0x3ff000000000000L & l) == 0L)
2065                      break;
2066                   if (kind > 106)
2067                      kind = 106;
2068                   jjCheckNAddStates(16, 18);
2069                   break;
2070                case 10:
2071                   if ((0x280000000000L & l) != 0L)
2072                      jjCheckNAdd(11);
2073                   break;
2074                case 11:
2075                   if ((0x3ff000000000000L & l) == 0L)
2076                      break;
2077                   if (kind > 106)
2078                      kind = 106;
2079                   jjCheckNAddTwoStates(11, 12);
2080                   break;
2081                case 14:
2082                   if ((0x3ff000000000000L & l) == 0L)
2083                      break;
2084                   if (kind > 124)
2085                      kind = 124;
2086                   jjstateSet[jjnewStateCnt++] = 14;
2087                   break;
2088                case 15:
2089                   if ((0x3ff000000000000L & l) != 0L)
2090                      jjCheckNAddStates(0, 6);
2091                   break;
2092                case 16:
2093                   if ((0x3ff000000000000L & l) != 0L)
2094                      jjCheckNAddTwoStates(16, 17);
2095                   break;
2096                case 17:
2097                   if (curChar != 46)
2098                      break;
2099                   if (kind > 106)
2100                      kind = 106;
2101                   jjCheckNAddStates(19, 21);
2102                   break;
2103                case 18:
2104                   if ((0x3ff000000000000L & l) == 0L)
2105                      break;
2106                   if (kind > 106)
2107                      kind = 106;
2108                   jjCheckNAddStates(19, 21);
2109                   break;
2110                case 20:
2111                   if ((0x280000000000L & l) != 0L)
2112                      jjCheckNAdd(21);
2113                   break;
2114                case 21:
2115                   if ((0x3ff000000000000L & l) == 0L)
2116                      break;
2117                   if (kind > 106)
2118                      kind = 106;
2119                   jjCheckNAddTwoStates(21, 12);
2120                   break;
2121                case 22:
2122                   if ((0x3ff000000000000L & l) != 0L)
2123                      jjCheckNAddTwoStates(22, 23);
2124                   break;
2125                case 24:
2126                   if ((0x280000000000L & l) != 0L)
2127                      jjCheckNAdd(25);
2128                   break;
2129                case 25:
2130                   if ((0x3ff000000000000L & l) == 0L)
2131                      break;
2132                   if (kind > 106)
2133                      kind = 106;
2134                   jjCheckNAddTwoStates(25, 12);
2135                   break;
2136                case 26:
2137                   if ((0x3ff000000000000L & l) != 0L)
2138                      jjCheckNAddStates(22, 24);
2139                   break;
2140                case 28:
2141                   if ((0x280000000000L & l) != 0L)
2142                      jjCheckNAdd(29);
2143                   break;
2144                case 29:
2145                   if ((0x3ff000000000000L & l) != 0L)
2146                      jjCheckNAddTwoStates(29, 12);
2147                   break;
2148                case 30:
2149                   if (curChar != 48)
2150                      break;
2151                   if (kind > 102)
2152                      kind = 102;
2153                   jjCheckNAddStates(13, 15);
2154                   break;
2155                case 32:
2156                   if ((0x3ff000000000000L & l) == 0L)
2157                      break;
2158                   if (kind > 102)
2159                      kind = 102;
2160                   jjCheckNAddTwoStates(32, 6);
2161                   break;
2162                case 33:
2163                   if ((0xff000000000000L & l) == 0L)
2164                      break;
2165                   if (kind > 102)
2166                      kind = 102;
2167                   jjCheckNAddTwoStates(33, 6);
2168                   break;
2169                case 34:
2170                   if (curChar == 39)
2171                      jjCheckNAddStates(7, 12);
2172                   break;
2173                case 35:
2174                   if ((0xffffff7fffffffffL & l) != 0L)
2175                      jjCheckNAddStates(25, 27);
2176                   break;
2177                case 37:
2178                   jjCheckNAddStates(25, 27);
2179                   break;
2180                case 38:
2181                   if (curChar == 39 && kind > 108)
2182                      kind = 108;
2183                   break;
2184                case 39:
2185                   if ((0xffffff7fffffffffL & l) != 0L)
2186                      jjCheckNAddStates(28, 30);
2187                   break;
2188                case 41:
2189                   jjCheckNAddStates(28, 30);
2190                   break;
2191                case 42:
2192                   if (curChar == 39 && kind > 109)
2193                      kind = 109;
2194                   break;
2195                case 44:
2196                case 46:
2197                   jjCheckNAddStates(31, 33);
2198                   break;
2199                case 48:
2200                case 50:
2201                   jjCheckNAddStates(34, 36);
2202                   break;
2203                default : break;
2204             }
2205          } while(i != startsAt);
2206       }
2207       else if (curChar < 128)
2208       {
2209          long l = 1L << (curChar & 077);
2210          MatchLoop: do
2211          {
2212             switch(jjstateSet[--i])
2213             {
2214                case 3:
2215                   if ((0x87fffffe87fffffeL & l) != 0L)
2216                   {
2217                      if (kind > 124)
2218                         kind = 124;
2219                      jjCheckNAdd(14);
2220                   }
2221                   else if (curChar == 96)
2222                      jjCheckNAddStates(37, 42);
2223                   break;
2224                case 1:
2225                   if (kind > 18)
2226                      kind = 18;
2227                   break;
2228                case 6:
2229                   if ((0x100000001000L & l) != 0L && kind > 102)
2230                      kind = 102;
2231                   break;
2232                case 9:
2233                   if ((0x2000000020L & l) != 0L)
2234                      jjAddStates(43, 44);
2235                   break;
2236                case 12:
2237                   if ((0x5000000050L & l) != 0L && kind > 106)
2238                      kind = 106;
2239                   break;
2240                case 13:
2241                case 14:
2242                   if ((0x87fffffe87fffffeL & l) == 0L)
2243                      break;
2244                   if (kind > 124)
2245                      kind = 124;
2246                   jjCheckNAdd(14);
2247                   break;
2248                case 19:
2249                   if ((0x2000000020L & l) != 0L)
2250                      jjAddStates(45, 46);
2251                   break;
2252                case 23:
2253                   if ((0x2000000020L & l) != 0L)
2254                      jjAddStates(47, 48);
2255                   break;
2256                case 27:
2257                   if ((0x2000000020L & l) != 0L)
2258                      jjAddStates(49, 50);
2259                   break;
2260                case 31:
2261                   if ((0x100000001000000L & l) != 0L)
2262                      jjCheckNAdd(32);
2263                   break;
2264                case 32:
2265                   if ((0x7e0000007eL & l) == 0L)
2266                      break;
2267                   if (kind > 102)
2268                      kind = 102;
2269                   jjCheckNAddTwoStates(32, 6);
2270                   break;
2271                case 35:
2272                   if ((0xffffffffefffffffL & l) != 0L)
2273                      jjCheckNAddStates(25, 27);
2274                   break;
2275                case 36:
2276                   if (curChar == 92)
2277                      jjstateSet[jjnewStateCnt++] = 37;
2278                   break;
2279                case 37:
2280                   jjCheckNAddStates(25, 27);
2281                   break;
2282                case 39:
2283                   if ((0xffffffffefffffffL & l) != 0L)
2284                      jjCheckNAddStates(28, 30);
2285                   break;
2286                case 40:
2287                   if (curChar == 92)
2288                      jjstateSet[jjnewStateCnt++] = 41;
2289                   break;
2290                case 41:
2291                   jjCheckNAddStates(28, 30);
2292                   break;
2293                case 43:
2294                   if (curChar == 96)
2295                      jjCheckNAddStates(37, 42);
2296                   break;
2297                case 44:
2298                   if ((0xfffffffeefffffffL & l) != 0L)
2299                      jjCheckNAddStates(31, 33);
2300                   break;
2301                case 45:
2302                   if (curChar == 92)
2303                      jjstateSet[jjnewStateCnt++] = 46;
2304                   break;
2305                case 46:
2306                   jjCheckNAddStates(31, 33);
2307                   break;
2308                case 47:
2309                   if (curChar == 96 && kind > 108)
2310                      kind = 108;
2311                   break;
2312                case 48:
2313                   if ((0xfffffffeefffffffL & l) != 0L)
2314                      jjCheckNAddStates(34, 36);
2315                   break;
2316                case 49:
2317                   if (curChar == 92)
2318                      jjstateSet[jjnewStateCnt++] = 50;
2319                   break;
2320                case 50:
2321                   jjCheckNAddStates(34, 36);
2322                   break;
2323                case 51:
2324                   if (curChar == 96 && kind > 110)
2325                      kind = 110;
2326                   break;
2327                default : break;
2328             }
2329          } while(i != startsAt);
2330       }
2331       else
2332       {
2333          int i2 = (curChar & 0xff) >> 6;
2334          long l2 = 1L << (curChar & 077);
2335          MatchLoop: do
2336          {
2337             switch(jjstateSet[--i])
2338             {
2339                case 3:
2340                case 14:
2341                   if ((jjbitVec0[i2] & l2) == 0L)
2342                      break;
2343                   if (kind > 124)
2344                      kind = 124;
2345                   jjCheckNAdd(14);
2346                   break;
2347                case 1:
2348                   if ((jjbitVec0[i2] & l2) != 0L && kind > 18)
2349                      kind = 18;
2350                   break;
2351                case 35:
2352                case 37:
2353                   if ((jjbitVec0[i2] & l2) != 0L)
2354                      jjCheckNAddStates(25, 27);
2355                   break;
2356                case 39:
2357                case 41:
2358                   if ((jjbitVec0[i2] & l2) != 0L)
2359                      jjCheckNAddStates(28, 30);
2360                   break;
2361                case 44:
2362                case 46:
2363                   if ((jjbitVec0[i2] & l2) != 0L)
2364                      jjCheckNAddStates(31, 33);
2365                   break;
2366                case 48:
2367                case 50:
2368                   if ((jjbitVec0[i2] & l2) != 0L)
2369                      jjCheckNAddStates(34, 36);
2370                   break;
2371                default : break;
2372             }
2373          } while(i != startsAt);
2374       }
2375       if (kind != 0x7fffffff)
2376       {
2377          jjmatchedKind = kind;
2378          jjmatchedPos = curPos;
2379          kind = 0x7fffffff;
2380       }
2381       ++curPos;
2382       if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
2383          return curPos;
2384       try { curChar = input_stream.readChar(); }
2385       catch(java.io.IOException e) { return curPos; }
2386    }
2387 }
2388 private static final int jjStopStringLiteralDfa_7(int pos, long active0, long active1)
2389 {
2390    switch (pos)
2391    {
2392       default :
2393          return -1;
2394    }
2395 }
2396 private static final int jjStartNfa_7(int pos, long active0, long active1)
2397 {
2398    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1), pos + 1);
2399 }
2400 static private final int jjStartNfaWithStates_7(int pos, int kind, int state)
2401 {
2402    jjmatchedKind = kind;
2403    jjmatchedPos = pos;
2404    try { curChar = input_stream.readChar(); }
2405    catch(java.io.IOException e) { return pos + 1; }
2406    return jjMoveNfa_7(state, pos + 1);
2407 }
2408 static private final int jjMoveStringLiteralDfa0_7()
2409 {
2410    switch(curChar)
2411    {
2412       case 34:
2413          return jjStopAtPos(0, 114);
2414       case 123:
2415          return jjStopAtPos(0, 115);
2416       default :
2417          return jjMoveNfa_7(0, 0);
2418    }
2419 }
2420 static private final int jjMoveNfa_7(int startState, int curPos)
2421 {
2422    int[] nextStates;
2423    int startsAt = 0;
2424    jjnewStateCnt = 4;
2425    int i = 1;
2426    jjstateSet[0] = startState;
2427    int j, kind = 0x7fffffff;
2428    for (;;)
2429    {
2430       if (++jjround == 0x7fffffff)
2431          ReInitRounds();
2432       if (curChar < 64)
2433       {
2434          long l = 1L << curChar;
2435          MatchLoop: do
2436          {
2437             switch(jjstateSet[--i])
2438             {
2439                case 1:
2440                   if (kind > 111)
2441                      kind = 111;
2442                   break;
2443                case 3:
2444                   if ((0x3ff000000000000L & l) == 0L)
2445                      break;
2446                   if (kind > 124)
2447                      kind = 124;
2448                   jjstateSet[jjnewStateCnt++] = 3;
2449                   break;
2450                default : break;
2451             }
2452          } while(i != startsAt);
2453       }
2454       else if (curChar < 128)
2455       {
2456          long l = 1L << (curChar & 077);
2457          MatchLoop: do
2458          {
2459             switch(jjstateSet[--i])
2460             {
2461                case 0:
2462                   if ((0x87fffffe87fffffeL & l) != 0L)
2463                   {
2464                      if (kind > 124)
2465                         kind = 124;
2466                      jjCheckNAdd(3);
2467                   }
2468                   else if (curChar == 92)
2469                      jjstateSet[jjnewStateCnt++] = 1;
2470                   break;
2471                case 1:
2472                   if (kind > 111)
2473                      kind = 111;
2474                   break;
2475                case 2:
2476                case 3:
2477                   if ((0x87fffffe87fffffeL & l) == 0L)
2478                      break;
2479                   if (kind > 124)
2480                      kind = 124;
2481                   jjCheckNAdd(3);
2482                   break;
2483                default : break;
2484             }
2485          } while(i != startsAt);
2486       }
2487       else
2488       {
2489          int i2 = (curChar & 0xff) >> 6;
2490          long l2 = 1L << (curChar & 077);
2491          MatchLoop: do
2492          {
2493             switch(jjstateSet[--i])
2494             {
2495                case 0:
2496                case 3:
2497                   if ((jjbitVec0[i2] & l2) == 0L)
2498                      break;
2499                   if (kind > 124)
2500                      kind = 124;
2501                   jjCheckNAdd(3);
2502                   break;
2503                case 1:
2504                   if ((jjbitVec0[i2] & l2) != 0L && kind > 111)
2505                      kind = 111;
2506                   break;
2507                default : break;
2508             }
2509          } while(i != startsAt);
2510       }
2511       if (kind != 0x7fffffff)
2512       {
2513          jjmatchedKind = kind;
2514          jjmatchedPos = curPos;
2515          kind = 0x7fffffff;
2516       }
2517       ++curPos;
2518       if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2519          return curPos;
2520       try { curChar = input_stream.readChar(); }
2521       catch(java.io.IOException e) { return curPos; }
2522    }
2523 }
2524 static final int[] jjnextStates = {
2525    16, 17, 22, 23, 26, 27, 12, 35, 36, 38, 39, 40, 42, 31, 33, 6,
2526    8, 9, 12, 18, 19, 12, 26, 27, 12, 35, 36, 38, 39, 40, 42, 44,
2527    45, 47, 48, 49, 51, 44, 45, 47, 48, 49, 51, 10, 11, 20, 21, 24,
2528    25, 28, 29,
2529 };
2530 public static final String[] jjstrLiteralImages = {
2531 "", "\74\77", null, "\74\77\75", "\77\76", null, null, null, null, null, null,
2532 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2533 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2534 null, null, null, null, null, null, "\55\76", "\72\72", "\75\76", null, null, null,
2535 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2536 null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2537 null, "\100", "\41", "\176", "\77", "\72", "\174\174", "\46\46", "\53\53", "\55\55",
2538 "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76",
2539 "\76\76\76", null, null, null, null, null, null, null, null, null, null, null, null, "\42",
2540 "\44", "\42", "\173", null, null, null, "\175", null, null, null, "\44", null, null,
2541 null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
2542 "\76", "\74", "\75\75", "\74\75", "\76\75", "\41\75", "\74\76", "\41\75\75",
2543 "\75\75\75", "\75", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75",
2544 "\56\75", "\45\75", "\176\75", "\74\74\75", "\76\76\75", };
2545 public static final String[] lexStateNames = {
2546    "DEFAULT",
2547    "PHPPARSING",
2548    "IN_SINGLE_LINE_COMMENT",
2549    "IN_VARIABLE",
2550    "IN_FORMAL_COMMENT",
2551    "IN_MULTI_LINE_COMMENT",
2552    "IN_STRING",
2553    "DOLLAR_IN_STRING",
2554    "SKIPSTRING",
2555    "DOLLAR_IN_STRING_EXPR",
2556 };
2557 public static final int[] jjnewLexState = {
2558    -1, 1, 1, 1, 0, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 2, 2, 4, 5, 1, -1, -1, -1, 1,
2559    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,
2560    -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,
2561    -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,
2562    1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6, 6, 7, 1, 9, 8, 6, -1, 7, -1, -1, -1, 3, -1,
2563    -1, -1, -1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2564    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2565 };
2566 static final long[] jjtoToken = {
2567    0xfffffffff880001fL, 0x198f747fffffffffL, 0xfffffffeL,
2568 };
2569 static final long[] jjtoSkip = {
2570    0x37fffe0L, 0x670800000000000L, 0x1L,
2571 };
2572 static final long[] jjtoSpecial = {
2573    0x37ff800L, 0x30000000000000L, 0x1L,
2574 };
2575 static final long[] jjtoMore = {
2576    0x4000000L, 0x0L, 0x0L,
2577 };
2578 static protected SimpleCharStream input_stream;
2579 static private final int[] jjrounds = new int[52];
2580 static private final int[] jjstateSet = new int[104];
2581 static StringBuffer image;
2582 static int jjimageLen;
2583 static int lengthOfMatch;
2584 static protected char curChar;
2585 public PHPParserTokenManager(SimpleCharStream stream)
2586 {
2587    if (input_stream != null)
2588       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
2589    input_stream = stream;
2590 }
2591 public PHPParserTokenManager(SimpleCharStream stream, int lexState)
2592 {
2593    this(stream);
2594    SwitchTo(lexState);
2595 }
2596 static public void ReInit(SimpleCharStream stream)
2597 {
2598    jjmatchedPos = jjnewStateCnt = 0;
2599    curLexState = defaultLexState;
2600    input_stream = stream;
2601    ReInitRounds();
2602 }
2603 static private final void ReInitRounds()
2604 {
2605    int i;
2606    jjround = 0x80000001;
2607    for (i = 52; i-- > 0;)
2608       jjrounds[i] = 0x80000000;
2609 }
2610 static public void ReInit(SimpleCharStream stream, int lexState)
2611 {
2612    ReInit(stream);
2613    SwitchTo(lexState);
2614 }
2615 static public void SwitchTo(int lexState)
2616 {
2617    if (lexState >= 10 || lexState < 0)
2618       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2619    else
2620       curLexState = lexState;
2621 }
2622
2623 static protected Token jjFillToken()
2624 {
2625    Token t = Token.newToken(jjmatchedKind);
2626    t.kind = jjmatchedKind;
2627    if (jjmatchedPos < 0)
2628    {
2629       t.image = "";
2630       t.beginLine = t.endLine = input_stream.getBeginLine();
2631       t.beginColumn = t.endColumn = input_stream.getBeginColumn();
2632    }
2633    else
2634    {
2635       String im = jjstrLiteralImages[jjmatchedKind];
2636       t.image = (im == null) ? input_stream.GetImage() : im;
2637       t.beginLine = input_stream.getBeginLine();
2638       t.beginColumn = input_stream.getBeginColumn();
2639       t.endLine = input_stream.getEndLine();
2640       t.endColumn = input_stream.getEndColumn();
2641    }
2642    return t;
2643 }
2644
2645 static int curLexState = 0;
2646 static int defaultLexState = 0;
2647 static int jjnewStateCnt;
2648 static int jjround;
2649 static int jjmatchedPos;
2650 static int jjmatchedKind;
2651
2652 public static Token getNextToken()
2653 {
2654   int kind;
2655   Token specialToken = null;
2656   Token matchedToken;
2657   int curPos = 0;
2658
2659   EOFLoop :
2660   for (;;)
2661   {
2662    try
2663    {
2664       curChar = input_stream.BeginToken();
2665    }
2666    catch(java.io.IOException e)
2667    {
2668       jjmatchedKind = 0;
2669       matchedToken = jjFillToken();
2670       matchedToken.specialToken = specialToken;
2671       CommonTokenAction(matchedToken);
2672       return matchedToken;
2673    }
2674    image = null;
2675    jjimageLen = 0;
2676
2677    for (;;)
2678    {
2679      switch(curLexState)
2680      {
2681        case 0:
2682          jjmatchedKind = 0x7fffffff;
2683          jjmatchedPos = 0;
2684          curPos = jjMoveStringLiteralDfa0_0();
2685          if (jjmatchedPos == 0 && jjmatchedKind > 5)
2686          {
2687             jjmatchedKind = 5;
2688          }
2689          break;
2690        case 1:
2691          try { input_stream.backup(0);
2692             while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2693                curChar = input_stream.BeginToken();
2694          }
2695          catch (java.io.IOException e1) { continue EOFLoop; }
2696          jjmatchedKind = 0x7fffffff;
2697          jjmatchedPos = 0;
2698          curPos = jjMoveStringLiteralDfa0_1();
2699          break;
2700        case 2:
2701          jjmatchedKind = 0x7fffffff;
2702          jjmatchedPos = 0;
2703          curPos = jjMoveStringLiteralDfa0_2();
2704          if (jjmatchedPos == 0 && jjmatchedKind > 21)
2705          {
2706             jjmatchedKind = 21;
2707          }
2708          break;
2709        case 3:
2710          jjmatchedKind = 0x7fffffff;
2711          jjmatchedPos = 0;
2712          curPos = jjMoveStringLiteralDfa0_3();
2713          break;
2714        case 4:
2715          jjmatchedKind = 0x7fffffff;
2716          jjmatchedPos = 0;
2717          curPos = jjMoveStringLiteralDfa0_4();
2718          if (jjmatchedPos == 0 && jjmatchedKind > 26)
2719          {
2720             jjmatchedKind = 26;
2721          }
2722          break;
2723        case 5:
2724          jjmatchedKind = 0x7fffffff;
2725          jjmatchedPos = 0;
2726          curPos = jjMoveStringLiteralDfa0_5();
2727          if (jjmatchedPos == 0 && jjmatchedKind > 26)
2728          {
2729             jjmatchedKind = 26;
2730          }
2731          break;
2732        case 6:
2733          jjmatchedKind = 0x7fffffff;
2734          jjmatchedPos = 0;
2735          curPos = jjMoveStringLiteralDfa0_6();
2736          if (jjmatchedPos == 0 && jjmatchedKind > 121)
2737          {
2738             jjmatchedKind = 121;
2739          }
2740          break;
2741        case 7:
2742          jjmatchedKind = 0x7fffffff;
2743          jjmatchedPos = 0;
2744          curPos = jjMoveStringLiteralDfa0_7();
2745          if (jjmatchedPos == 0 && jjmatchedKind > 128)
2746          {
2747             jjmatchedKind = 128;
2748          }
2749          break;
2750        case 8:
2751          jjmatchedKind = 0x7fffffff;
2752          jjmatchedPos = 0;
2753          curPos = jjMoveStringLiteralDfa0_8();
2754          if (jjmatchedPos == 0 && jjmatchedKind > 118)
2755          {
2756             jjmatchedKind = 118;
2757          }
2758          break;
2759        case 9:
2760          jjmatchedKind = 120;
2761          jjmatchedPos = -1;
2762          curPos = 0;
2763          curPos = jjMoveStringLiteralDfa0_9();
2764          if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 122))
2765          {
2766             jjmatchedKind = 122;
2767             jjmatchedPos = 0;
2768          }
2769          break;
2770      }
2771      if (jjmatchedKind != 0x7fffffff)
2772      {
2773         if (jjmatchedPos + 1 < curPos)
2774            input_stream.backup(curPos - jjmatchedPos - 1);
2775         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2776         {
2777            matchedToken = jjFillToken();
2778            matchedToken.specialToken = specialToken;
2779            TokenLexicalActions(matchedToken);
2780        if (jjnewLexState[jjmatchedKind] != -1)
2781          curLexState = jjnewLexState[jjmatchedKind];
2782            CommonTokenAction(matchedToken);
2783            return matchedToken;
2784         }
2785         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2786         {
2787            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2788            {
2789               matchedToken = jjFillToken();
2790               if (specialToken == null)
2791                  specialToken = matchedToken;
2792               else
2793               {
2794                  matchedToken.specialToken = specialToken;
2795                  specialToken = (specialToken.next = matchedToken);
2796               }
2797               SkipLexicalActions(matchedToken);
2798            }
2799            else
2800               SkipLexicalActions(null);
2801          if (jjnewLexState[jjmatchedKind] != -1)
2802            curLexState = jjnewLexState[jjmatchedKind];
2803            continue EOFLoop;
2804         }
2805         jjimageLen += jjmatchedPos + 1;
2806       if (jjnewLexState[jjmatchedKind] != -1)
2807         curLexState = jjnewLexState[jjmatchedKind];
2808         curPos = 0;
2809         jjmatchedKind = 0x7fffffff;
2810         try {
2811            curChar = input_stream.readChar();
2812            continue;
2813         }
2814         catch (java.io.IOException e1) { }
2815      }
2816      int error_line = input_stream.getEndLine();
2817      int error_column = input_stream.getEndColumn();
2818      String error_after = null;
2819      boolean EOFSeen = false;
2820      try { input_stream.readChar(); input_stream.backup(1); }
2821      catch (java.io.IOException e1) {
2822         EOFSeen = true;
2823         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2824         if (curChar == '\n' || curChar == '\r') {
2825            error_line++;
2826            error_column = 0;
2827         }
2828         else
2829            error_column++;
2830      }
2831      if (!EOFSeen) {
2832         input_stream.backup(1);
2833         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2834      }
2835      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2836    }
2837   }
2838 }
2839
2840 static void SkipLexicalActions(Token matchedToken)
2841 {
2842    switch(jjmatchedKind)
2843    {
2844       case 18 :
2845          if (image == null)
2846             image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2847          else
2848             image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
2849                    input_stream.backup(1);
2850          break;
2851       default :
2852          break;
2853    }
2854 }
2855 static void TokenLexicalActions(Token matchedToken)
2856 {
2857    switch(jjmatchedKind)
2858    {
2859       default :
2860          break;
2861    }
2862 }
2863 }