PageRenderTime 132ms CodeModel.GetById 18ms app.highlight 102ms RepoModel.GetById 1ms app.codeStats 1ms

/jEdit/tags/jedit-4-0-pre3/bsh/ParserTokenManager.java

#
Java | 1964 lines | 1956 code | 7 blank | 1 comment | 560 complexity | 0ef78978c91020f9ced4b3d63cc5a66a MD5 | raw file
   1/* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
   2package bsh;
   3import java.io.Reader;
   4
   5class ParserTokenManager implements ParserConstants
   6{
   7private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
   8{
   9   switch (pos)
  10   {
  11      case 0:
  12         if ((active0 & 0x3eL) != 0L)
  13            return 0;
  14         if ((active1 & 0x400040000000L) != 0L)
  15            return 56;
  16         if ((active1 & 0x20L) != 0L)
  17            return 11;
  18         if ((active0 & 0x3fffffffff800L) != 0L)
  19         {
  20            jjmatchedKind = 58;
  21            return 35;
  22         }
  23         return -1;
  24      case 1:
  25         if ((active0 & 0x3ffffbf9ff800L) != 0L)
  26         {
  27            if (jjmatchedPos != 1)
  28            {
  29               jjmatchedKind = 58;
  30               jjmatchedPos = 1;
  31            }
  32            return 35;
  33         }
  34         if ((active0 & 0x40600000L) != 0L)
  35            return 35;
  36         return -1;
  37      case 2:
  38         if ((active0 & 0x37fe9afdff800L) != 0L)
  39         {
  40            if (jjmatchedPos != 2)
  41            {
  42               jjmatchedKind = 58;
  43               jjmatchedPos = 2;
  44            }
  45            return 35;
  46         }
  47         if ((active0 & 0x801610000000L) != 0L)
  48            return 35;
  49         return -1;
  50      case 3:
  51         if ((active0 & 0x140282082c000L) != 0L)
  52            return 35;
  53         if ((active0 & 0x23fc58f5d3800L) != 0L)
  54         {
  55            if (jjmatchedPos != 3)
  56            {
  57               jjmatchedKind = 58;
  58               jjmatchedPos = 3;
  59            }
  60            return 35;
  61         }
  62         return -1;
  63      case 4:
  64         if ((active0 & 0x1bc580580800L) != 0L)
  65         {
  66            if (jjmatchedPos != 4)
  67            {
  68               jjmatchedKind = 58;
  69               jjmatchedPos = 4;
  70            }
  71            return 35;
  72         }
  73         if ((active0 & 0x224000f053000L) != 0L)
  74            return 35;
  75         return -1;
  76      case 5:
  77         if ((active0 & 0xc504180800L) != 0L)
  78         {
  79            jjmatchedKind = 58;
  80            jjmatchedPos = 5;
  81            return 35;
  82         }
  83         if ((active0 & 0x1b0080400000L) != 0L)
  84            return 35;
  85         return -1;
  86      case 6:
  87         if ((active0 & 0x4004100800L) != 0L)
  88            return 35;
  89         if ((active0 & 0x8500080000L) != 0L)
  90         {
  91            jjmatchedKind = 58;
  92            jjmatchedPos = 6;
  93            return 35;
  94         }
  95         return -1;
  96      case 7:
  97         if ((active0 & 0x8500000000L) != 0L)
  98         {
  99            jjmatchedKind = 58;
 100            jjmatchedPos = 7;
 101            return 35;
 102         }
 103         if ((active0 & 0x80000L) != 0L)
 104            return 35;
 105         return -1;
 106      case 8:
 107         if ((active0 & 0x100000000L) != 0L)
 108         {
 109            jjmatchedKind = 58;
 110            jjmatchedPos = 8;
 111            return 35;
 112         }
 113         if ((active0 & 0x8400000000L) != 0L)
 114            return 35;
 115         return -1;
 116      case 9:
 117         if ((active0 & 0x100000000L) != 0L)
 118            return 35;
 119         return -1;
 120      default :
 121         return -1;
 122   }
 123}
 124private final int jjStartNfa_0(int pos, long active0, long active1)
 125{
 126   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
 127}
 128private final int jjStopAtPos(int pos, int kind)
 129{
 130   jjmatchedKind = kind;
 131   jjmatchedPos = pos;
 132   return pos + 1;
 133}
 134private final int jjStartNfaWithStates_0(int pos, int kind, int state)
 135{
 136   jjmatchedKind = kind;
 137   jjmatchedPos = pos;
 138   try { curChar = input_stream.readChar(); }
 139   catch(java.io.IOException e) { return pos + 1; }
 140   return jjMoveNfa_0(state, pos + 1);
 141}
 142private final int jjMoveStringLiteralDfa0_0()
 143{
 144   switch(curChar)
 145   {
 146      case 9:
 147         return jjStartNfaWithStates_0(0, 2, 0);
 148      case 10:
 149         return jjStartNfaWithStates_0(0, 5, 0);
 150      case 12:
 151         return jjStartNfaWithStates_0(0, 4, 0);
 152      case 13:
 153         return jjStartNfaWithStates_0(0, 3, 0);
 154      case 32:
 155         return jjStartNfaWithStates_0(0, 1, 0);
 156      case 33:
 157         jjmatchedKind = 75;
 158         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000L);
 159      case 37:
 160         jjmatchedKind = 100;
 161         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
 162      case 38:
 163         jjmatchedKind = 95;
 164         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000800000L);
 165      case 40:
 166         return jjStopAtPos(0, 61);
 167      case 41:
 168         return jjStopAtPos(0, 62);
 169      case 42:
 170         jjmatchedKind = 93;
 171         return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000L);
 172      case 43:
 173         jjmatchedKind = 91;
 174         return jjMoveStringLiteralDfa1_0(0x0L, 0x80002000000L);
 175      case 44:
 176         return jjStopAtPos(0, 68);
 177      case 45:
 178         jjmatchedKind = 92;
 179         return jjMoveStringLiteralDfa1_0(0x0L, 0x100004000000L);
 180      case 46:
 181         return jjStartNfaWithStates_0(0, 69, 11);
 182      case 47:
 183         jjmatchedKind = 94;
 184         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000000000L);
 185      case 58:
 186         return jjStopAtPos(0, 78);
 187      case 59:
 188         return jjStopAtPos(0, 67);
 189      case 60:
 190         jjmatchedKind = 73;
 191         return jjMoveStringLiteralDfa1_0(0x0L, 0x20002000010000L);
 192      case 61:
 193         jjmatchedKind = 70;
 194         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000L);
 195      case 62:
 196         jjmatchedKind = 71;
 197         return jjMoveStringLiteralDfa1_0(0x0L, 0x280028000040000L);
 198      case 63:
 199         return jjStopAtPos(0, 77);
 200      case 64:
 201         return jjMoveStringLiteralDfa1_0(0x0L, 0x5450545014a0500L);
 202      case 91:
 203         return jjStopAtPos(0, 65);
 204      case 93:
 205         return jjStopAtPos(0, 66);
 206      case 94:
 207         jjmatchedKind = 99;
 208         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
 209      case 98:
 210         return jjMoveStringLiteralDfa1_0(0x5800L, 0x0L);
 211      case 99:
 212         return jjMoveStringLiteralDfa1_0(0xfa000L, 0x0L);
 213      case 100:
 214         return jjMoveStringLiteralDfa1_0(0x700000L, 0x0L);
 215      case 101:
 216         return jjMoveStringLiteralDfa1_0(0x800000L, 0x0L);
 217      case 102:
 218         return jjMoveStringLiteralDfa1_0(0x1f000000L, 0x0L);
 219      case 103:
 220         return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
 221      case 105:
 222         return jjMoveStringLiteralDfa1_0(0x7c0000000L, 0x0L);
 223      case 108:
 224         return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L);
 225      case 110:
 226         return jjMoveStringLiteralDfa1_0(0x3000000000L, 0x0L);
 227      case 112:
 228         return jjMoveStringLiteralDfa1_0(0x1c000000000L, 0x0L);
 229      case 114:
 230         return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L);
 231      case 115:
 232         return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L);
 233      case 116:
 234         return jjMoveStringLiteralDfa1_0(0xe00000000000L, 0x0L);
 235      case 118:
 236         return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
 237      case 119:
 238         return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
 239      case 123:
 240         return jjStopAtPos(0, 63);
 241      case 124:
 242         jjmatchedKind = 97;
 243         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000200000L);
 244      case 125:
 245         return jjStopAtPos(0, 64);
 246      case 126:
 247         return jjStopAtPos(0, 76);
 248      default :
 249         return jjMoveNfa_0(6, 0);
 250   }
 251}
 252private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
 253{
 254   try { curChar = input_stream.readChar(); }
 255   catch(java.io.IOException e) {
 256      jjStopStringLiteralDfa_0(0, active0, active1);
 257      return 1;
 258   }
 259   switch(curChar)
 260   {
 261      case 38:
 262         if ((active1 & 0x800000L) != 0L)
 263            return jjStopAtPos(1, 87);
 264         break;
 265      case 43:
 266         if ((active1 & 0x2000000L) != 0L)
 267            return jjStopAtPos(1, 89);
 268         break;
 269      case 45:
 270         if ((active1 & 0x4000000L) != 0L)
 271            return jjStopAtPos(1, 90);
 272         break;
 273      case 60:
 274         if ((active1 & 0x2000000000L) != 0L)
 275         {
 276            jjmatchedKind = 101;
 277            jjmatchedPos = 1;
 278         }
 279         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000000000000L);
 280      case 61:
 281         if ((active1 & 0x8000L) != 0L)
 282            return jjStopAtPos(1, 79);
 283         else if ((active1 & 0x10000L) != 0L)
 284            return jjStopAtPos(1, 80);
 285         else if ((active1 & 0x40000L) != 0L)
 286            return jjStopAtPos(1, 82);
 287         else if ((active1 & 0x100000L) != 0L)
 288            return jjStopAtPos(1, 84);
 289         else if ((active1 & 0x80000000000L) != 0L)
 290            return jjStopAtPos(1, 107);
 291         else if ((active1 & 0x100000000000L) != 0L)
 292            return jjStopAtPos(1, 108);
 293         else if ((active1 & 0x200000000000L) != 0L)
 294            return jjStopAtPos(1, 109);
 295         else if ((active1 & 0x400000000000L) != 0L)
 296            return jjStopAtPos(1, 110);
 297         else if ((active1 & 0x800000000000L) != 0L)
 298            return jjStopAtPos(1, 111);
 299         else if ((active1 & 0x2000000000000L) != 0L)
 300            return jjStopAtPos(1, 113);
 301         else if ((active1 & 0x8000000000000L) != 0L)
 302            return jjStopAtPos(1, 115);
 303         else if ((active1 & 0x10000000000000L) != 0L)
 304            return jjStopAtPos(1, 116);
 305         break;
 306      case 62:
 307         if ((active1 & 0x8000000000L) != 0L)
 308         {
 309            jjmatchedKind = 103;
 310            jjmatchedPos = 1;
 311         }
 312         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x280020000000000L);
 313      case 97:
 314         return jjMoveStringLiteralDfa2_0(active0, 0x1018000L, active1, 0x1000001000000L);
 315      case 98:
 316         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x500000000L);
 317      case 101:
 318         return jjMoveStringLiteralDfa2_0(active0, 0x21000100000L, active1, 0L);
 319      case 102:
 320         if ((active0 & 0x40000000L) != 0L)
 321            return jjStartNfaWithStates_0(1, 30, 35);
 322         break;
 323      case 103:
 324         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80100L);
 325      case 104:
 326         return jjMoveStringLiteralDfa2_0(active0, 0x2240000020000L, active1, 0L);
 327      case 105:
 328         return jjMoveStringLiteralDfa2_0(active0, 0x6000000L, active1, 0L);
 329      case 108:
 330         return jjMoveStringLiteralDfa2_0(active0, 0x8802000L, active1, 0x40004000020400L);
 331      case 109:
 332         return jjMoveStringLiteralDfa2_0(active0, 0x80000000L, active1, 0L);
 333      case 110:
 334         return jjMoveStringLiteralDfa2_0(active0, 0x700000000L, active1, 0L);
 335      case 111:
 336         if ((active0 & 0x200000L) != 0L)
 337         {
 338            jjmatchedKind = 21;
 339            jjmatchedPos = 1;
 340         }
 341         return jjMoveStringLiteralDfa2_0(active0, 0x10008304c0800L, active1, 0x4000000400000L);
 342      case 114:
 343         return jjMoveStringLiteralDfa2_0(active0, 0xc0c000001000L, active1, 0x500050000000000L);
 344      case 116:
 345         return jjMoveStringLiteralDfa2_0(active0, 0x80000000000L, active1, 0L);
 346      case 117:
 347         return jjMoveStringLiteralDfa2_0(active0, 0x12000000000L, active1, 0L);
 348      case 119:
 349         return jjMoveStringLiteralDfa2_0(active0, 0x100000000000L, active1, 0L);
 350      case 121:
 351         return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
 352      case 124:
 353         if ((active1 & 0x200000L) != 0L)
 354            return jjStopAtPos(1, 85);
 355         break;
 356      default :
 357         break;
 358   }
 359   return jjStartNfa_0(0, active0, active1);
 360}
 361private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
 362{
 363   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 364      return jjStartNfa_0(0, old0, old1); 
 365   try { curChar = input_stream.readChar(); }
 366   catch(java.io.IOException e) {
 367      jjStopStringLiteralDfa_0(1, active0, active1);
 368      return 2;
 369   }
 370   switch(curChar)
 371   {
 372      case 61:
 373         if ((active1 & 0x20000000000000L) != 0L)
 374            return jjStopAtPos(2, 117);
 375         else if ((active1 & 0x80000000000000L) != 0L)
 376            return jjStopAtPos(2, 119);
 377         break;
 378      case 62:
 379         if ((active1 & 0x20000000000L) != 0L)
 380         {
 381            jjmatchedKind = 105;
 382            jjmatchedPos = 2;
 383         }
 384         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
 385      case 97:
 386         return jjMoveStringLiteralDfa3_0(active0, 0x80000022000L, active1, 0L);
 387      case 98:
 388         return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L, active1, 0L);
 389      case 101:
 390         return jjMoveStringLiteralDfa3_0(active0, 0x1000L, active1, 0x40004000000000L);
 391      case 102:
 392         return jjMoveStringLiteralDfa3_0(active0, 0x100000L, active1, 0L);
 393      case 105:
 394         return jjMoveStringLiteralDfa3_0(active0, 0x3104000000000L, active1, 0x500050500000000L);
 395      case 108:
 396         return jjMoveStringLiteralDfa3_0(active0, 0x2001000000L, active1, 0L);
 397      case 110:
 398         return jjMoveStringLiteralDfa3_0(active0, 0x8060c0000L, active1, 0x1000001000000L);
 399      case 111:
 400         return jjMoveStringLiteralDfa3_0(active0, 0x48008000800L, active1, 0L);
 401      case 112:
 402         return jjMoveStringLiteralDfa3_0(active0, 0x80000000L, active1, 0L);
 403      case 114:
 404         if ((active0 & 0x10000000L) != 0L)
 405            return jjStartNfaWithStates_0(2, 28, 35);
 406         else if ((active1 & 0x400000L) != 0L)
 407         {
 408            jjmatchedKind = 86;
 409            jjmatchedPos = 2;
 410         }
 411         return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0x4000000000000L);
 412      case 115:
 413         return jjMoveStringLiteralDfa3_0(active0, 0x100808000L, active1, 0L);
 414      case 116:
 415         if ((active0 & 0x200000000L) != 0L)
 416         {
 417            jjmatchedKind = 33;
 418            jjmatchedPos = 2;
 419         }
 420         else if ((active1 & 0x100L) != 0L)
 421         {
 422            jjmatchedKind = 72;
 423            jjmatchedPos = 2;
 424         }
 425         else if ((active1 & 0x400L) != 0L)
 426         {
 427            jjmatchedKind = 74;
 428            jjmatchedPos = 2;
 429         }
 430         return jjMoveStringLiteralDfa3_0(active0, 0x20420014000L, active1, 0xa0000L);
 431      case 117:
 432         return jjMoveStringLiteralDfa3_0(active0, 0x400000400000L, active1, 0L);
 433      case 119:
 434         if ((active0 & 0x1000000000L) != 0L)
 435            return jjStartNfaWithStates_0(2, 36, 35);
 436         break;
 437      case 121:
 438         if ((active0 & 0x800000000000L) != 0L)
 439            return jjStartNfaWithStates_0(2, 47, 35);
 440         break;
 441      default :
 442         break;
 443   }
 444   return jjStartNfa_0(1, active0, active1);
 445}
 446private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
 447{
 448   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 449      return jjStartNfa_0(1, old0, old1); 
 450   try { curChar = input_stream.readChar(); }
 451   catch(java.io.IOException e) {
 452      jjStopStringLiteralDfa_0(2, active0, active1);
 453      return 3;
 454   }
 455   switch(curChar)
 456   {
 457      case 61:
 458         if ((active1 & 0x200000000000000L) != 0L)
 459            return jjStopAtPos(3, 121);
 460         break;
 461      case 95:
 462         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x4000000000000L);
 463      case 97:
 464         return jjMoveStringLiteralDfa4_0(active0, 0xe101000L, active1, 0L);
 465      case 98:
 466         return jjMoveStringLiteralDfa4_0(active0, 0x400000L, active1, 0L);
 467      case 99:
 468         return jjMoveStringLiteralDfa4_0(active0, 0x10000L, active1, 0L);
 469      case 100:
 470         if ((active0 & 0x1000000000000L) != 0L)
 471            return jjStartNfaWithStates_0(3, 48, 35);
 472         else if ((active1 & 0x1000000L) != 0L)
 473         {
 474            jjmatchedKind = 88;
 475            jjmatchedPos = 3;
 476         }
 477         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x1000000000000L);
 478      case 101:
 479         if ((active0 & 0x4000L) != 0L)
 480            return jjStartNfaWithStates_0(3, 14, 35);
 481         else if ((active0 & 0x8000L) != 0L)
 482            return jjStartNfaWithStates_0(3, 15, 35);
 483         else if ((active0 & 0x800000L) != 0L)
 484            return jjStartNfaWithStates_0(3, 23, 35);
 485         else if ((active0 & 0x400000000000L) != 0L)
 486            return jjStartNfaWithStates_0(3, 46, 35);
 487         return jjMoveStringLiteralDfa4_0(active0, 0x400000000L, active1, 0xa0000L);
 488      case 102:
 489         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40004000000000L);
 490      case 103:
 491         if ((active0 & 0x800000000L) != 0L)
 492            return jjStartNfaWithStates_0(3, 35, 35);
 493         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x500050000000000L);
 494      case 108:
 495         if ((active0 & 0x2000000000L) != 0L)
 496            return jjStartNfaWithStates_0(3, 37, 35);
 497         return jjMoveStringLiteralDfa4_0(active0, 0x2010000000800L, active1, 0L);
 498      case 111:
 499         if ((active0 & 0x20000000L) != 0L)
 500            return jjStartNfaWithStates_0(3, 29, 35);
 501         return jjMoveStringLiteralDfa4_0(active0, 0x200080000000L, active1, 0L);
 502      case 114:
 503         if ((active0 & 0x20000L) != 0L)
 504            return jjStartNfaWithStates_0(3, 17, 35);
 505         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L, active1, 0L);
 506      case 115:
 507         return jjMoveStringLiteralDfa4_0(active0, 0x1042000L, active1, 0L);
 508      case 116:
 509         return jjMoveStringLiteralDfa4_0(active0, 0x188100080000L, active1, 0x500000000L);
 510      case 117:
 511         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L);
 512      case 118:
 513         return jjMoveStringLiteralDfa4_0(active0, 0x4000000000L, active1, 0L);
 514      default :
 515         break;
 516   }
 517   return jjStartNfa_0(2, active0, active1);
 518}
 519private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
 520{
 521   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 522      return jjStartNfa_0(2, old0, old1); 
 523   try { curChar = input_stream.readChar(); }
 524   catch(java.io.IOException e) {
 525      jjStopStringLiteralDfa_0(3, active0, active1);
 526      return 4;
 527   }
 528   switch(curChar)
 529   {
 530      case 95:
 531         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000000000000L);
 532      case 97:
 533         return jjMoveStringLiteralDfa5_0(active0, 0x4100000000L, active1, 0x4000000000000L);
 534      case 99:
 535         return jjMoveStringLiteralDfa5_0(active0, 0x100000000000L, active1, 0L);
 536      case 101:
 537         if ((active0 & 0x1000000L) != 0L)
 538            return jjStartNfaWithStates_0(4, 24, 35);
 539         else if ((active0 & 0x2000000000000L) != 0L)
 540            return jjStartNfaWithStates_0(4, 49, 35);
 541         return jjMoveStringLiteralDfa5_0(active0, 0x8000000800L, active1, 0L);
 542      case 104:
 543         if ((active0 & 0x10000L) != 0L)
 544            return jjStartNfaWithStates_0(4, 16, 35);
 545         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x500050000000000L);
 546      case 105:
 547         return jjMoveStringLiteralDfa5_0(active0, 0x90000080000L, active1, 0L);
 548      case 107:
 549         if ((active0 & 0x1000L) != 0L)
 550            return jjStartNfaWithStates_0(4, 12, 35);
 551         break;
 552      case 108:
 553         if ((active0 & 0x2000000L) != 0L)
 554         {
 555            jjmatchedKind = 25;
 556            jjmatchedPos = 4;
 557         }
 558         return jjMoveStringLiteralDfa5_0(active0, 0x4400000L, active1, 0L);
 559      case 113:
 560         if ((active1 & 0x20000L) != 0L)
 561            return jjStopAtPos(4, 81);
 562         else if ((active1 & 0x80000L) != 0L)
 563            return jjStopAtPos(4, 83);
 564         break;
 565      case 114:
 566         return jjMoveStringLiteralDfa5_0(active0, 0x20480000000L, active1, 0L);
 567      case 115:
 568         if ((active0 & 0x2000L) != 0L)
 569            return jjStartNfaWithStates_0(4, 13, 35);
 570         break;
 571      case 116:
 572         if ((active0 & 0x40000L) != 0L)
 573            return jjStartNfaWithStates_0(4, 18, 35);
 574         else if ((active0 & 0x8000000L) != 0L)
 575            return jjStartNfaWithStates_0(4, 27, 35);
 576         else if ((active0 & 0x40000000000L) != 0L)
 577            return jjStartNfaWithStates_0(4, 42, 35);
 578         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x40004000000000L);
 579      case 117:
 580         return jjMoveStringLiteralDfa5_0(active0, 0x100000L, active1, 0L);
 581      case 119:
 582         if ((active0 & 0x200000000000L) != 0L)
 583            return jjStartNfaWithStates_0(4, 45, 35);
 584         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x500000000L);
 585      default :
 586         break;
 587   }
 588   return jjStartNfa_0(3, active0, active1);
 589}
 590private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
 591{
 592   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 593      return jjStartNfa_0(3, old0, old1); 
 594   try { curChar = input_stream.readChar(); }
 595   catch(java.io.IOException e) {
 596      jjStopStringLiteralDfa_0(4, active0, active1);
 597      return 5;
 598   }
 599   switch(curChar)
 600   {
 601      case 95:
 602         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x40004000000000L);
 603      case 97:
 604         return jjMoveStringLiteralDfa6_0(active0, 0x800L, active1, 0x1000000000000L);
 605      case 99:
 606         if ((active0 & 0x10000000000L) != 0L)
 607            return jjStartNfaWithStates_0(5, 40, 35);
 608         else if ((active0 & 0x80000000000L) != 0L)
 609            return jjStartNfaWithStates_0(5, 43, 35);
 610         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
 611      case 101:
 612         if ((active0 & 0x400000L) != 0L)
 613            return jjStartNfaWithStates_0(5, 22, 35);
 614         break;
 615      case 102:
 616         return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0L);
 617      case 104:
 618         if ((active0 & 0x100000000000L) != 0L)
 619            return jjStartNfaWithStates_0(5, 44, 35);
 620         break;
 621      case 105:
 622         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x500000000L);
 623      case 108:
 624         return jjMoveStringLiteralDfa6_0(active0, 0x4100000L, active1, 0L);
 625      case 110:
 626         if ((active0 & 0x20000000000L) != 0L)
 627            return jjStartNfaWithStates_0(5, 41, 35);
 628         return jjMoveStringLiteralDfa6_0(active0, 0x100080000L, active1, 0L);
 629      case 115:
 630         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x4000000000000L);
 631      case 116:
 632         if ((active0 & 0x80000000L) != 0L)
 633            return jjStartNfaWithStates_0(5, 31, 35);
 634         return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L, active1, 0x500050000000000L);
 635      default :
 636         break;
 637   }
 638   return jjStartNfa_0(4, active0, active1);
 639}
 640private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
 641{
 642   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 643      return jjStartNfa_0(4, old0, old1); 
 644   try { curChar = input_stream.readChar(); }
 645   catch(java.io.IOException e) {
 646      jjStopStringLiteralDfa_0(5, active0, active1);
 647      return 6;
 648   }
 649   switch(curChar)
 650   {
 651      case 95:
 652         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x500050000000000L);
 653      case 97:
 654         return jjMoveStringLiteralDfa7_0(active0, 0x400000000L, active1, 0L);
 655      case 99:
 656         return jjMoveStringLiteralDfa7_0(active0, 0x100000000L, active1, 0L);
 657      case 101:
 658         if ((active0 & 0x4000000000L) != 0L)
 659            return jjStartNfaWithStates_0(6, 38, 35);
 660         break;
 661      case 110:
 662         if ((active0 & 0x800L) != 0L)
 663            return jjStartNfaWithStates_0(6, 11, 35);
 664         break;
 665      case 115:
 666         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x45004500000000L);
 667      case 116:
 668         if ((active0 & 0x100000L) != 0L)
 669            return jjStartNfaWithStates_0(6, 20, 35);
 670         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L, active1, 0L);
 671      case 117:
 672         return jjMoveStringLiteralDfa7_0(active0, 0x80000L, active1, 0L);
 673      case 121:
 674         if ((active0 & 0x4000000L) != 0L)
 675            return jjStartNfaWithStates_0(6, 26, 35);
 676         break;
 677      default :
 678         break;
 679   }
 680   return jjStartNfa_0(5, active0, active1);
 681}
 682private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
 683{
 684   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 685      return jjStartNfa_0(5, old0, old1); 
 686   try { curChar = input_stream.readChar(); }
 687   catch(java.io.IOException e) {
 688      jjStopStringLiteralDfa_0(6, active0, active1);
 689      return 7;
 690   }
 691   switch(curChar)
 692   {
 693      case 99:
 694         return jjMoveStringLiteralDfa8_0(active0, 0x400000000L, active1, 0L);
 695      case 101:
 696         if ((active0 & 0x80000L) != 0L)
 697            return jjStartNfaWithStates_0(7, 19, 35);
 698         return jjMoveStringLiteralDfa8_0(active0, 0x8100000000L, active1, 0x500000000L);
 699      case 104:
 700         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x40004000000000L);
 701      case 105:
 702         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x4000000000000L);
 703      case 115:
 704         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x101010000000000L);
 705      case 117:
 706         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x400040000000000L);
 707      default :
 708         break;
 709   }
 710   return jjStartNfa_0(6, active0, active1);
 711}
 712private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
 713{
 714   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 715      return jjStartNfa_0(6, old0, old1); 
 716   try { curChar = input_stream.readChar(); }
 717   catch(java.io.IOException e) {
 718      jjStopStringLiteralDfa_0(7, active0, active1);
 719      return 8;
 720   }
 721   switch(curChar)
 722   {
 723      case 95:
 724         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x500000000L);
 725      case 100:
 726         if ((active0 & 0x8000000000L) != 0L)
 727            return jjStartNfaWithStates_0(8, 39, 35);
 728         break;
 729      case 101:
 730         if ((active0 & 0x400000000L) != 0L)
 731            return jjStartNfaWithStates_0(8, 34, 35);
 732         break;
 733      case 103:
 734         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x4000000000000L);
 735      case 104:
 736         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x100010000000000L);
 737      case 105:
 738         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x41004000000000L);
 739      case 110:
 740         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x400040000000000L);
 741      case 111:
 742         return jjMoveStringLiteralDfa9_0(active0, 0x100000000L, active1, 0L);
 743      default :
 744         break;
 745   }
 746   return jjStartNfa_0(7, active0, active1);
 747}
 748private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
 749{
 750   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 751      return jjStartNfa_0(7, old0, old1); 
 752   try { curChar = input_stream.readChar(); }
 753   catch(java.io.IOException e) {
 754      jjStopStringLiteralDfa_0(8, active0, active1);
 755      return 9;
 756   }
 757   switch(curChar)
 758   {
 759      case 97:
 760         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x100000000L);
 761      case 102:
 762         if ((active0 & 0x100000000L) != 0L)
 763            return jjStartNfaWithStates_0(9, 32, 35);
 764         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x40004000000000L);
 765      case 103:
 766         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x1000000000000L);
 767      case 105:
 768         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x100010000000000L);
 769      case 110:
 770         if ((active1 & 0x4000000000000L) != 0L)
 771            return jjStopAtPos(9, 114);
 772         break;
 773      case 111:
 774         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x400000000L);
 775      case 115:
 776         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x400040000000000L);
 777      default :
 778         break;
 779   }
 780   return jjStartNfa_0(8, active0, active1);
 781}
 782private final int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1)
 783{
 784   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 785      return jjStartNfa_0(8, old0, old1); 
 786   try { curChar = input_stream.readChar(); }
 787   catch(java.io.IOException e) {
 788      jjStopStringLiteralDfa_0(9, 0L, active1);
 789      return 10;
 790   }
 791   switch(curChar)
 792   {
 793      case 102:
 794         return jjMoveStringLiteralDfa11_0(active1, 0x100010000000000L);
 795      case 105:
 796         return jjMoveStringLiteralDfa11_0(active1, 0x400040000000000L);
 797      case 110:
 798         if ((active1 & 0x1000000000000L) != 0L)
 799            return jjStopAtPos(10, 112);
 800         return jjMoveStringLiteralDfa11_0(active1, 0x100000000L);
 801      case 114:
 802         if ((active1 & 0x400000000L) != 0L)
 803            return jjStopAtPos(10, 98);
 804         break;
 805      case 116:
 806         if ((active1 & 0x4000000000L) != 0L)
 807         {
 808            jjmatchedKind = 102;
 809            jjmatchedPos = 10;
 810         }
 811         return jjMoveStringLiteralDfa11_0(active1, 0x40000000000000L);
 812      default :
 813         break;
 814   }
 815   return jjStartNfa_0(9, 0L, active1);
 816}
 817private final int jjMoveStringLiteralDfa11_0(long old1, long active1)
 818{
 819   if (((active1 &= old1)) == 0L)
 820      return jjStartNfa_0(9, 0L, old1); 
 821   try { curChar = input_stream.readChar(); }
 822   catch(java.io.IOException e) {
 823      jjStopStringLiteralDfa_0(10, 0L, active1);
 824      return 11;
 825   }
 826   switch(curChar)
 827   {
 828      case 95:
 829         return jjMoveStringLiteralDfa12_0(active1, 0x40000000000000L);
 830      case 100:
 831         if ((active1 & 0x100000000L) != 0L)
 832            return jjStopAtPos(11, 96);
 833         break;
 834      case 103:
 835         return jjMoveStringLiteralDfa12_0(active1, 0x400040000000000L);
 836      case 116:
 837         if ((active1 & 0x10000000000L) != 0L)
 838         {
 839            jjmatchedKind = 104;
 840            jjmatchedPos = 11;
 841         }
 842         return jjMoveStringLiteralDfa12_0(active1, 0x100000000000000L);
 843      default :
 844         break;
 845   }
 846   return jjStartNfa_0(10, 0L, active1);
 847}
 848private final int jjMoveStringLiteralDfa12_0(long old1, long active1)
 849{
 850   if (((active1 &= old1)) == 0L)
 851      return jjStartNfa_0(10, 0L, old1); 
 852   try { curChar = input_stream.readChar(); }
 853   catch(java.io.IOException e) {
 854      jjStopStringLiteralDfa_0(11, 0L, active1);
 855      return 12;
 856   }
 857   switch(curChar)
 858   {
 859      case 95:
 860         return jjMoveStringLiteralDfa13_0(active1, 0x100000000000000L);
 861      case 97:
 862         return jjMoveStringLiteralDfa13_0(active1, 0x40000000000000L);
 863      case 110:
 864         return jjMoveStringLiteralDfa13_0(active1, 0x400040000000000L);
 865      default :
 866         break;
 867   }
 868   return jjStartNfa_0(11, 0L, active1);
 869}
 870private final int jjMoveStringLiteralDfa13_0(long old1, long active1)
 871{
 872   if (((active1 &= old1)) == 0L)
 873      return jjStartNfa_0(11, 0L, old1); 
 874   try { curChar = input_stream.readChar(); }
 875   catch(java.io.IOException e) {
 876      jjStopStringLiteralDfa_0(12, 0L, active1);
 877      return 13;
 878   }
 879   switch(curChar)
 880   {
 881      case 97:
 882         return jjMoveStringLiteralDfa14_0(active1, 0x100000000000000L);
 883      case 101:
 884         return jjMoveStringLiteralDfa14_0(active1, 0x400040000000000L);
 885      case 115:
 886         return jjMoveStringLiteralDfa14_0(active1, 0x40000000000000L);
 887      default :
 888         break;
 889   }
 890   return jjStartNfa_0(12, 0L, active1);
 891}
 892private final int jjMoveStringLiteralDfa14_0(long old1, long active1)
 893{
 894   if (((active1 &= old1)) == 0L)
 895      return jjStartNfa_0(12, 0L, old1); 
 896   try { curChar = input_stream.readChar(); }
 897   catch(java.io.IOException e) {
 898      jjStopStringLiteralDfa_0(13, 0L, active1);
 899      return 14;
 900   }
 901   switch(curChar)
 902   {
 903      case 100:
 904         return jjMoveStringLiteralDfa15_0(active1, 0x400040000000000L);
 905      case 115:
 906         return jjMoveStringLiteralDfa15_0(active1, 0x140000000000000L);
 907      default :
 908         break;
 909   }
 910   return jjStartNfa_0(13, 0L, active1);
 911}
 912private final int jjMoveStringLiteralDfa15_0(long old1, long active1)
 913{
 914   if (((active1 &= old1)) == 0L)
 915      return jjStartNfa_0(13, 0L, old1); 
 916   try { curChar = input_stream.readChar(); }
 917   catch(java.io.IOException e) {
 918      jjStopStringLiteralDfa_0(14, 0L, active1);
 919      return 15;
 920   }
 921   switch(curChar)
 922   {
 923      case 95:
 924         return jjMoveStringLiteralDfa16_0(active1, 0x400040000000000L);
 925      case 105:
 926         return jjMoveStringLiteralDfa16_0(active1, 0x40000000000000L);
 927      case 115:
 928         return jjMoveStringLiteralDfa16_0(active1, 0x100000000000000L);
 929      default :
 930         break;
 931   }
 932   return jjStartNfa_0(14, 0L, active1);
 933}
 934private final int jjMoveStringLiteralDfa16_0(long old1, long active1)
 935{
 936   if (((active1 &= old1)) == 0L)
 937      return jjStartNfa_0(14, 0L, old1); 
 938   try { curChar = input_stream.readChar(); }
 939   catch(java.io.IOException e) {
 940      jjStopStringLiteralDfa_0(15, 0L, active1);
 941      return 16;
 942   }
 943   switch(curChar)
 944   {
 945      case 103:
 946         return jjMoveStringLiteralDfa17_0(active1, 0x40000000000000L);
 947      case 105:
 948         return jjMoveStringLiteralDfa17_0(active1, 0x100000000000000L);
 949      case 115:
 950         return jjMoveStringLiteralDfa17_0(active1, 0x400040000000000L);
 951      default :
 952         break;
 953   }
 954   return jjStartNfa_0(15, 0L, active1);
 955}
 956private final int jjMoveStringLiteralDfa17_0(long old1, long active1)
 957{
 958   if (((active1 &= old1)) == 0L)
 959      return jjStartNfa_0(15, 0L, old1); 
 960   try { curChar = input_stream.readChar(); }
 961   catch(java.io.IOException e) {
 962      jjStopStringLiteralDfa_0(16, 0L, active1);
 963      return 17;
 964   }
 965   switch(curChar)
 966   {
 967      case 103:
 968         return jjMoveStringLiteralDfa18_0(active1, 0x100000000000000L);
 969      case 104:
 970         return jjMoveStringLiteralDfa18_0(active1, 0x400040000000000L);
 971      case 110:
 972         if ((active1 & 0x40000000000000L) != 0L)
 973            return jjStopAtPos(17, 118);
 974         break;
 975      default :
 976         break;
 977   }
 978   return jjStartNfa_0(16, 0L, active1);
 979}
 980private final int jjMoveStringLiteralDfa18_0(long old1, long active1)
 981{
 982   if (((active1 &= old1)) == 0L)
 983      return jjStartNfa_0(16, 0L, old1); 
 984   try { curChar = input_stream.readChar(); }
 985   catch(java.io.IOException e) {
 986      jjStopStringLiteralDfa_0(17, 0L, active1);
 987      return 18;
 988   }
 989   switch(curChar)
 990   {
 991      case 105:
 992         return jjMoveStringLiteralDfa19_0(active1, 0x400040000000000L);
 993      case 110:
 994         if ((active1 & 0x100000000000000L) != 0L)
 995            return jjStopAtPos(18, 120);
 996         break;
 997      default :
 998         break;
 999   }
1000   return jjStartNfa_0(17, 0L, active1);
1001}
1002private final int jjMoveStringLiteralDfa19_0(long old1, long active1)
1003{
1004   if (((active1 &= old1)) == 0L)
1005      return jjStartNfa_0(17, 0L, old1); 
1006   try { curChar = input_stream.readChar(); }
1007   catch(java.io.IOException e) {
1008      jjStopStringLiteralDfa_0(18, 0L, active1);
1009      return 19;
1010   }
1011   switch(curChar)
1012   {
1013      case 102:
1014         return jjMoveStringLiteralDfa20_0(active1, 0x400040000000000L);
1015      default :
1016         break;
1017   }
1018   return jjStartNfa_0(18, 0L, active1);
1019}
1020private final int jjMoveStringLiteralDfa20_0(long old1, long active1)
1021{
1022   if (((active1 &= old1)) == 0L)
1023      return jjStartNfa_0(18, 0L, old1); 
1024   try { curChar = input_stream.readChar(); }
1025   catch(java.io.IOException e) {
1026      jjStopStringLiteralDfa_0(19, 0L, active1);
1027      return 20;
1028   }
1029   switch(curChar)
1030   {
1031      case 116:
1032         if ((active1 & 0x40000000000L) != 0L)
1033         {
1034            jjmatchedKind = 106;
1035            jjmatchedPos = 20;
1036         }
1037         return jjMoveStringLiteralDfa21_0(active1, 0x400000000000000L);
1038      default :
1039         break;
1040   }
1041   return jjStartNfa_0(19, 0L, active1);
1042}
1043private final int jjMoveStringLiteralDfa21_0(long old1, long active1)
1044{
1045   if (((active1 &= old1)) == 0L)
1046      return jjStartNfa_0(19, 0L, old1); 
1047   try { curChar = input_stream.readChar(); }
1048   catch(java.io.IOException e) {
1049      jjStopStringLiteralDfa_0(20, 0L, active1);
1050      return 21;
1051   }
1052   switch(curChar)
1053   {
1054      case 95:
1055         return jjMoveStringLiteralDfa22_0(active1, 0x400000000000000L);
1056      default :
1057         break;
1058   }
1059   return jjStartNfa_0(20, 0L, active1);
1060}
1061private final int jjMoveStringLiteralDfa22_0(long old1, long active1)
1062{
1063   if (((active1 &= old1)) == 0L)
1064      return jjStartNfa_0(20, 0L, old1); 
1065   try { curChar = input_stream.readChar(); }
1066   catch(java.io.IOException e) {
1067      jjStopStringLiteralDfa_0(21, 0L, active1);
1068      return 22;
1069   }
1070   switch(curChar)
1071   {
1072      case 97:
1073         return jjMoveStringLiteralDfa23_0(active1, 0x400000000000000L);
1074      default :
1075         break;
1076   }
1077   return jjStartNfa_0(21, 0L, active1);
1078}
1079private final int jjMoveStringLiteralDfa23_0(long old1, long active1)
1080{
1081   if (((active1 &= old1)) == 0L)
1082      return jjStartNfa_0(21, 0L, old1); 
1083   try { curChar = input_stream.readChar(); }
1084   catch(java.io.IOException e) {
1085      jjStopStringLiteralDfa_0(22, 0L, active1);
1086      return 23;
1087   }
1088   switch(curChar)
1089   {
1090      case 115:
1091         return jjMoveStringLiteralDfa24_0(active1, 0x400000000000000L);
1092      default :
1093         break;
1094   }
1095   return jjStartNfa_0(22, 0L, active1);
1096}
1097private final int jjMoveStringLiteralDfa24_0(long old1, long active1)
1098{
1099   if (((active1 &= old1)) == 0L)
1100      return jjStartNfa_0(22, 0L, old1); 
1101   try { curChar = input_stream.readChar(); }
1102   catch(java.io.IOException e) {
1103      jjStopStringLiteralDfa_0(23, 0L, active1);
1104      return 24;
1105   }
1106   switch(curChar)
1107   {
1108      case 115:
1109         return jjMoveStringLiteralDfa25_0(active1, 0x400000000000000L);
1110      default :
1111         break;
1112   }
1113   return jjStartNfa_0(23, 0L, active1);
1114}
1115private final int jjMoveStringLiteralDfa25_0(long old1, long active1)
1116{
1117   if (((active1 &= old1)) == 0L)
1118      return jjStartNfa_0(23, 0L, old1); 
1119   try { curChar = input_stream.readChar(); }
1120   catch(java.io.IOException e) {
1121      jjStopStringLiteralDfa_0(24, 0L, active1);
1122      return 25;
1123   }
1124   switch(curChar)
1125   {
1126      case 105:
1127         return jjMoveStringLiteralDfa26_0(active1, 0x400000000000000L);
1128      default :
1129         break;
1130   }
1131   return jjStartNfa_0(24, 0L, active1);
1132}
1133private final int jjMoveStringLiteralDfa26_0(long old1, long active1)
1134{
1135   if (((active1 &= old1)) == 0L)
1136      return jjStartNfa_0(24, 0L, old1); 
1137   try { curChar = input_stream.readChar(); }
1138   catch(java.io.IOException e) {
1139      jjStopStringLiteralDfa_0(25, 0L, active1);
1140      return 26;
1141   }
1142   switch(curChar)
1143   {
1144      case 103:
1145         return jjMoveStringLiteralDfa27_0(active1, 0x400000000000000L);
1146      default :
1147         break;
1148   }
1149   return jjStartNfa_0(25, 0L, active1);
1150}
1151private final int jjMoveStringLiteralDfa27_0(long old1, long active1)
1152{
1153   if (((active1 &= old1)) == 0L)
1154      return jjStartNfa_0(25, 0L, old1); 
1155   try { curChar = input_stream.readChar(); }
1156   catch(java.io.IOException e) {
1157      jjStopStringLiteralDfa_0(26, 0L, active1);
1158      return 27;
1159   }
1160   switch(curChar)
1161   {
1162      case 110:
1163         if ((active1 & 0x400000000000000L) != 0L)
1164            return jjStopAtPos(27, 122);
1165         break;
1166      default :
1167         break;
1168   }
1169   return jjStartNfa_0(26, 0L, active1);
1170}
1171private final void jjCheckNAdd(int state)
1172{
1173   if (jjrounds[state] != jjround)
1174   {
1175      jjstateSet[jjnewStateCnt++] = state;
1176      jjrounds[state] = jjround;
1177   }
1178}
1179private final void jjAddStates(int start, int end)
1180{
1181   do {
1182      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1183   } while (start++ != end);
1184}
1185private final void jjCheckNAddTwoStates(int state1, int state2)
1186{
1187   jjCheckNAdd(state1);
1188   jjCheckNAdd(state2);
1189}
1190private final void jjCheckNAddStates(int start, int end)
1191{
1192   do {
1193      jjCheckNAdd(jjnextStates[start]);
1194   } while (start++ != end);
1195}
1196private final void jjCheckNAddStates(int start)
1197{
1198   jjCheckNAdd(jjnextStates[start]);
1199   jjCheckNAdd(jjnextStates[start + 1]);
1200}
1201static final long[] jjbitVec0 = {
1202   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1203};
1204static final long[] jjbitVec1 = {
1205   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1206};
1207static final long[] jjbitVec3 = {
1208   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
1209};
1210static final long[] jjbitVec4 = {
1211   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
1212};
1213static final long[] jjbitVec5 = {
1214   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1215};
1216static final long[] jjbitVec6 = {
1217   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
1218};
1219static final long[] jjbitVec7 = {
1220   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
1221};
1222static final long[] jjbitVec8 = {
1223   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
1224};
1225private final int jjMoveNfa_0(int startState, int curPos)
1226{
1227   int[] nextStates;
1228   int startsAt = 0;
1229   jjnewStateCnt = 74;
1230   int i = 1;
1231   jjstateSet[0] = startState;
1232   int j, kind = 0x7fffffff;
1233   for (;;)
1234   {
1235      if (++jjround == 0x7fffffff)
1236         ReInitRounds();
1237      if (curChar < 64)
1238      {
1239         long l = 1L << curChar;
1240         MatchLoop: do
1241         {
1242            switch(jjstateSet[--i])
1243            {
1244               case 6:
1245                  if ((0x1ffffffffL & l) != 0L)
1246                  {
1247                     if (kind > 6)
1248                        kind = 6;
1249                     jjCheckNAdd(0);
1250                  }
1251                  else if ((0x3ff000000000000L & l) != 0L)
1252                     jjCheckNAddStates(0, 6);
1253                  else if (curChar == 47)
1254                     jjAddStates(7, 9);
1255                  else if (curChar == 36)
1256                  {
1257                     if (kind > 58)
1258                        kind = 58;
1259                     jjCheckNAdd(35);
1260                  }
1261                  else if (curChar == 34)
1262                     jjCheckNAddStates(10, 12);
1263                  else if (curChar == 39)
1264                     jjAddStates(13, 14);
1265                  else if (curChar == 46)
1266                     jjCheckNAdd(11);
1267                  else if (curChar == 35)
1268                     jjstateSet[jjnewStateCnt++] = 1;
1269                  if ((0x3fe000000000000L & l) != 0L)
1270                  {
1271                     if (kind > 50)
1272                        kind = 50;
1273                     jjCheckNAddTwoStates(8, 9);
1274                  }
1275                  else if (curChar == 48)
1276                  {
1277                     if (kind > 50)
1278                        kind = 50;
1279                     jjCheckNAddStates(15, 17);
1280                  }
1281                  break;
1282               case 56:
1283                  if (curChar == 42)
1284                     jjCheckNAddTwoStates(69, 70);
1285                  else if (curChar == 47)
1286                  {
1287                     if (kind > 7)
1288                        kind = 7;
1289                     jjCheckNAddStates(18, 20);
1290                  }
1291                  if (curChar == 42)
1292                     jjstateSet[jjnewStateCnt++] = 61;
1293                  break;
1294               case 0:
1295                  if ((0x1ffffffffL & l) == 0L)
1296                     break;
1297                  if (kind > 6)
1298                     kind = 6;
1299                  jjCheckNAdd(0);
1300                  break;
1301               case 1:
1302                  if (curChar == 33)
1303                     jjCheckNAddStates(21, 23);
1304                  break;
1305               case 2:
1306                  if ((0xffffffffffffdbffL & l) != 0L)
1307                     jjCheckNAddStates(21, 23);
1308                  break;
1309               case 3:
1310                  if ((0x2400L & l) != 0L && kind > 8)
1311                     kind = 8;
1312                  break;
1313               case 4:
1314                  if (curChar == 10 && kind > 8)
1315                     kind = 8;
1316                  break;
1317               case 5:
1318                  if (curChar == 13)
1319                     jjstateSet[jjnewStateCnt++] = 4;
1320                  break;
1321               case 7:
1322                  if ((0x3fe000000000000L & l) == 0L)
1323                     break;
1324                  if (kind > 50)
1325                     kind = 50;
1326                  jjCheckNAddTwoStates(8, 9);
1327                  break;
1328               case 8:
1329                  if ((0x3ff000000000000L & l) == 0L)
1330                     break;
1331                  if (kind > 50)
1332                     kind = 50;
1333                  jjCheckNAddTwoStates(8, 9);
1334                  break;
1335               case 10:
1336                  if (curChar == 46)
1337                     jjCheckNAdd(11);
1338                  break;
1339               case 11:
1340                  if ((0x3ff000000000000L & l) == 0L)
1341                     break;
1342                  if (kind > 54)
1343                     kind = 54;
1344                  jjCheckNAddStates(24, 26);
1345                  break;
1346               case 13:
1347                  if ((0x280000000000L & l) != 0L)
1348                     jjCheckNAdd(14);
1349                  break;
1350               case 14:
1351                  if ((0x3ff000000000000L & l) == 0L)
1352                     break;
1353                  if (kind > 54)
1354                     kind = 54;
1355                  jjCheckNAddTwoStates(14, 15);
1356                  break;
1357               case 16:
1358                  if (curChar == 39)
1359                     jjAddStates(13, 14);
1360                  break;
1361               case 17:
1362                  if ((0xffffff7fffffdbffL & l) != 0L)
1363                     jjCheckNAdd(18);
1364                  break;
1365               case 18:
1366                  if (curChar == 39 && kind > 56)
1367                     kind = 56;
1368                  break;
1369               case 20:
1370                  if ((0x8400000000L & l) != 0L)
1371                     jjCheckNAdd(18);
1372                  break;
1373               case 21:
1374                  if ((0xff000000000000L & l) != 0L)
1375                     jjCheckNAddTwoStates(22, 18);
1376                  break;
1377               case 22:
1378                  if ((0xff000000000000L & l) != 0L)
1379                     jjCheckNAdd(18);
1380                  break;
1381               case 23:
1382                  if ((0xf000000000000L & l) != 0L)
1383                     jjstateSet[jjnewStateCnt++] = 24;
1384                  break;
1385               case 24:
1386                  if ((0xff000000000000L & l) != 0L)
1387                     jjCheckNAdd(22);
1388                  break;
1389               case 25:
1390                  if (curChar == 34)
1391                     jjCheckNAddStates(10, 12);
1392                  break;
1393               case 26:
1394                  if ((0xfffffffbffffdbffL & l) != 0L)
1395                     jjCheckNAddStates(10, 12);
1396                  break;
1397               case 28:
1398                  if ((0x8400000000L & l) != 0L)
1399                     jjCheckNAddStates(10, 12);
1400                  break;
1401               case 29:
1402                  if (curChar == 34 && kind > 57)
1403                     kind = 57;
1404                  break;
1405               case 30:
1406                  if ((0xff000000000000L & l) != 0L)
1407                     jjCheckNAddStates(27, 30);
1408                  break;
1409               case 31:
1410                  if ((0xff000000000000L & l) != 0L)
1411                     jjCheckNAddStates(10, 12);
1412                  break;
1413               case 32:
1414                  if ((0xf000000000000L & l) != 0L)
1415                     jjstateSet[jjnewStateCnt++] = 33;
1416                  break;
1417               case 33:
1418                  if ((0xff000000000000L & l) != 0L)
1419                     jjCheckNAdd(31);
1420                  break;
1421               case 34:
1422                  if (curChar != 36)
1423                     break;
1424                  if (kind > 58)
1425                     kind = 58;
1426                  jjCheckNAdd(35);
1427                  break;
1428               case 35:
1429                  if ((0x3ff001000000000L & l) == 0L)
1430                     break;
1431                  if (kind > 58)
1432                     kind = 58;
1433                  jjCheckNAdd(35);
1434                  break;
1435               case 36:
1436                  if ((0x3ff000000000000L & l) != 0L)
1437                     jjCheckNAddStates(0, 6);
1438                  break;
1439               case 37:
1440                  if ((0x3ff000000000000L & l) != 0L)
1441                     jjCheckNAddTwoStates(37, 38);
1442                  break;
1443               case 38:
1444                  if (curChar != 46)
1445                     break;
1446                  if (kind > 54)
1447                     kind = 54;
1448                  jjCheckNAddStates(31, 33);
1449                  break;
1450               case 39:
1451                  if ((0x3ff000000000000L & l) == 0L)
1452                     break;
1453                  if (kind > 54)
1454                     kind = 54;
1455                  jjCheckNAddStates(31, 33);
1456                  break;
1457               case 41:
1458                  if ((0x280000000000L & l) != 0L)
1459                     jjCheckNAdd(42);
1460                  break;
1461               case 42:
1462                  if ((0x3ff000000000000L & l) == 0L)
1463                     break;
1464                  if (kind > 54)
1465                     kind = 54;
1466                  jjCheckNAddTwoStates(42, 15);
1467                  break;
1468               case 43:
1469                  if ((0x3ff000000000000L & l) != 0L)
1470                     jjCheckNAddTwoStates(43, 44);
1471                  break;
1472               case 45:
1473                  if ((0x280000000000L & l) != 0L)
1474                     jjCheckNAdd(46);
1475                  break;
1476               case 46:
1477                  if ((0x3ff000000000000L & l) == 0L)
1478                     break;
1479                  if (kind > 54)
1480                     kind = 54;
1481                  jjCheckNAddTwoStates(46, 15);
1482                  break;
1483               case 47:
1484                  if ((0x3ff000000000000L & l) != 0L)
1485                     jjCheckNAddStates(34, 36);
1486                  break;
1487               case 49:
1488                  if ((0x280000000000L & l) != 0L)
1489                     jjCheckNAdd(50);
1490                  break;
1491               case 50:
1492                  if ((0x3ff000000000000L & l) != 0L)
1493                     jjCheckNAddTwoStates(50, 15);
1494                  break;
1495               case 51:
1496                  if (curChar != 48)
1497                     break;
1498                  if (kind > 50)
1499                     kind = 50;
1500                  jjCheckNAddStates(15, 17);
1501                  break;
1502               case 53:
1503                  if ((0x3ff000000000000L & l) == 0L)
1504                     break;
1505                  if (kind > 50)
1506                     kind = 50;
1507                  jjCheckNAddTwoStates(53, 9);
1508                  break;
1509               case 54:
1510                  if ((0xff000000000000L & l) == 0L)
1511                     break;
1512                  if (kind > 50)
1513                     kind = 50;
1514                  jjCheckNAddTwoStates(54, 9);
1515                  break;
1516               case 55:
1517                  if (curChar == 47)
1518                     jjAddStates(7, 9);
1519                  break;
1520               case 57:
1521                  if ((0xffffffffffffdbffL & l) == 0L)
1522                     break;
1523                  if (kind > 7)
1524                     kind = 7;
1525                  jjCheckNAddStates(18, 20);
1526                  break;
1527               case 58:
1528                  if ((0x2400L & l) != 0L && kind > 7)
1529                     kind = 7;
1530                  break;
1531               case 59:
1532                  if (curChar == 10 && kind > 7)
1533                     kind = 7;
1534                  break;
1535               case 60:
1536                  if (curChar == 13)
1537                     jjstateSet[jjnewStateCnt++] = 59;
1538                  break;
1539               case 61:
1540                  if (curChar == 42)
1541                     jjCheckNAddTwoStates(62, 63);
1542                  break;
1543               case 62:
1544                  if ((0xfffffbffffffffffL & l) != 0L)
1545                     jjCheckNAddTwoStates(62, 63);
1546                  break;
1547               case 63:
1548                  if (curChar == 42)
1549                     jjCheckNAddStates(37, 39);
1550                  break;
1551               case 64:
1552                  if ((0xffff7bffffffffffL & l) != 0L)
1553                     jjCheckNAddTwoStates(65, 63);
1554                  break;
1555               case 65:
1556                  if ((0xfffffbffffffffffL & l) != 0L)
1557                     jjCheckNAddTwoStates(65, 63);
1558                  break;
1559               case 66:
1560                  if (curChar == 47 && kind > 9)
1561                     kind = 9;
1562                  break;
1563               case 67:
1564                  if (curChar == 42)
1565                     jjstateSet[jjnewStateCnt++] = 61;
1566                  break;
1567               case 68:
1568                  if (curChar == 42)
1569                     jjCheckNAddTwoStates(69, 70);
1570                  break;
1571               case 69:
1572                  if ((0xfffffbffffffffffL & l) != 0L)
1573                     jjCheckNAddTwoStates(69, 70);
1574                  break;
1575               case 70:
1576                  if (curChar == 42)
1577                     jjCheckNAddStates(40, 42);
1578                  break;
1579               case 71:
1580                  if ((0xffff7bffffffffffL & l) != 0L)
1581                     jjCheckNAddTwoStates(72, 70);
1582                  break;
1583               case 72:
1584                  if ((0xfffffbffffffffffL & l) != 0L)
1585                     jjCheckNAddTwoStates(72, 70);
1586                  break;
1587               case 73:
1588                  if (curChar == 47 && kind > 10)
1589                     kind = 10;
1590                  break;
1591               default : break;
1592            }
1593         } while(i != startsAt);
1594      }
1595      else if (curChar < 128)
1596      {
1597         long l = 1L << (curChar & 077);
1598         MatchLoop: do
1599         {
1600            switch(jjstateSet[--i])
1601            {
1602               case 6:
1603               case 35:
1604                  if ((0x7fffffe87fffffeL & l) == 0L)
1605                     break;
1606                  if (kind > 58)
1607                     kind = 58;
1608                  jjCheckNAdd(35);
1609                  break;
1610               case 2:
1611                  jjAddStates(21, 23);
1612                  break;
1613               case 9:
1614                  if ((0x100000001000L & l) != 0L && kind > 50)
1615                     kind = 50;
1616                  break;
1617               case 12:
1618                  if ((0x2000000020L & l) != 0L)
1619                     jjAddStates(43, 44);
1620                  break;
1621               case 15:
1622                  if ((0x5000000050L & l) != 0L && kind > 54)
1623                     kind = 54;
1624                  break;
1625               case 17:
1626                  if ((0xffffffffefffffffL & l) != 0L)
1627                     jjCheckNAdd(18);
1628                  break;
1629               case 19:
1630                  if (curChar == 92)
1631                     jjAddStates(45, 47);
1632                  break;
1633               case 20:
1634                  if ((0x14404410000000L & l) != 0L)
1635                     jjCheckNAdd(18);
1636                  break;
1637               case 26:
1638                  if ((0xffffffffefffffffL & l) != 0L)
1639                     jjCheckNAddStates(10, 12);
1640                  break;
1641               case 27:
1642                  if (curChar == 92)
1643                     jjAddStates(48, 50);
1644                  break;
1645               case 28:
1646                  if ((0x14404410000000L & l) != 0L)
1647                     jjCheckNAddStates(10, 12);
1648                  break;
1649               case 40:
1650                  if ((0x2000000020L & l) != 0L)
1651                     jjAddStates(51, 52);
1652                  break;
1653               case 44:
1654                  if ((0x2000000020L & l) != 0L)
1655                     jjAddStates(53, 54);
1656                  break;
1657               case 48:
1658                  if ((0x2000000020L & l) != 0L)
1659                     jjAddStates(55, 56);
1660                  break;
1661               case 52:
1662                  if ((0x100000001000000L & l) != 0L)
1663                     jjCheckNAdd(53);
1664                  break;
1665               case 53:
1666                  if ((0x7e0000007eL & l) == 0L)
1667                     break;
1668                  if (kind > 50)
1669                     kind = 50;
1670                  jjCheckNAddTwoStates(53, 9);
1671                  break;
1672               case 57:
1673                  if (kind > 7)
1674                     kind = 7;
1675                  jjAddStates(18, 20);
1676                  break;
1677               case 62:
1678                  jjCheckNAddTwoStates(62, 63);
1679                  break;
1680               case 64:
1681               case 65:
1682                  jjCheckNAddTwoStates(65, 63);
1683                  break;
1684               case 69:
1685                  jjCheckNAddTwoStates(69, 70);
1686                  break;
1687               case 71:
1688               case 72:
1689                  jjCheckNAddTwoStates(72, 70);
1690                  break;
1691               default : break;
1692            }
1693         } while(i != startsAt);
1694      }
1695      else
1696      {
1697         int hiByte = (int)(curChar >> 8);
1698         int i1 = hiByte >> 6;
1699         long l1 = 1L << (hiByte & 077);
1700         int i2 = (curChar & 0xff) >> 6;
1701         long l2 = 1L << (curChar & 077);
1702         MatchLoop: do
1703         {
1704            switch(jjstateSet[--i])
1705            {
1706               case 6:
1707                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1708                  {
1709                     if (kind > 6)
1710                        kind = 6;
1711                     jjCheckNAdd(0);
1712                  }
1713                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1714                  {
1715                     if (kind > 58)
1716                        kind = 58;
1717                     jjCheckNAdd(35);
1718                  }
1719                  break;
1720               case 0:
1721                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1722                     break;
1723                  if (kind > 6)
1724                     kind = 6;
1725                  jjCheckNAdd(0);
1726                  break;
1727               case 2:
1728                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1729                     jjAddStates(21, 23);
1730                  break;
1731               case 17:
1732                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1733                     jjstateSet[jjnewStateCnt++] = 18;
1734                  break;
1735               case 26:
1736                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1737                     jjAddStates(10, 12);
1738                  break;
1739               case 34:
1740               case 35:
1741                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1742                     break;
1743                  if (kind > 58)
1744                     kind = 58;
1745                  jjCheckNAdd(35);
1746                  break;
1747               case 57:
1748                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1749                     break;
1750                  if (kind > 7)
1751                     kind = 7;
1752                  jjAddStates(18, 20);
1753                  break;
1754               case 62:
1755                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1756                     jjCheckNAddTwoStates(62, 63);
1757                  break;
1758               case 64:
1759               case 65:
1760                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1761                     jjCheckNAddTwoStates(65, 63);
1762                  break;
1763               case 69:
1764                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1765                     jjCheckNAddTwoStates(69, 70);
1766                  break;
1767               case 71:
1768               case 72:
1769                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1770                     jjCheckNAddTwoStates(72, 70);
1771                  break;
1772               default : break;
1773            }
1774         } while(i != startsAt);
1775      }
1776      if (kind != 0x7fffffff)
1777      {
1778         jjmatchedKind = kind;
1779         jjmatchedPos = curPos;
1780         kind = 0x7fffffff;
1781      }
1782      ++curPos;
1783      if ((i = jjnewStateCnt) == (startsAt = 74 - (jjnewStateCnt = startsAt)))
1784         return curPos;
1785      try { curChar = input_stream.readChar(); }
1786      catch(java.io.IOException e) { return curPos; }
1787   }
1788}
1789static final int[] jjnextStates = {
1790   37, 38, 43, 44, 47, 48, 15, 56, 67, 68, 26, 27, 29, 17, 19, 52, 
1791   54, 9, 57, 58, 60, 2, 3, 5, 11, 12, 15, 26, 27, 31, 29, 39, 
1792   40, 15, 47, 48, 15, 63, 64, 66, 70, 71, 73, 13, 14, 20, 21, 23, 
1793   28, 30, 32, 41, 42, 45, 46, 49, 50, 
1794};
1795private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1796{
1797   switch(hiByte)
1798   {
1799      case 0:
1800         return ((jjbitVec0[i2] & l2) != 0L);
1801      default : 
1802         return false;
1803   }
1804}
1805private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1806{
1807   switch(hiByte)
1808   {
1809      case 0:
1810         return ((jjbitVec0[i2] & l2) != 0L);
1811      default : 
1812         if ((jjbitVec1[i1] & l1) != 0L)
1813            return true;
1814         return false;
1815   }
1816}
1817private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1818{
1819   switch(hiByte)
1820   {
1821      case 0:
1822         return ((jjbitVec4[i2] & l2) != 0L);
1823      case 48:
1824         return ((jjbitVec5[i2] & l2) != 0L);
1825      case 49:
1826         return ((jjbitVec6[i2] & l2) != 0L);
1827      case 51:
1828         return ((jjbitVec7[i2] & l2) != 0L);
1829      case 61:
1830         return ((jjbitVec8[i2] & l2) != 0L);
1831      default : 
1832         if ((jjbitVec3[i1] & l1) != 0L)
1833            return true;
1834         return false;
1835   }
1836}
1837public static final String[] jjstrLiteralImages = {
1838"", null, null, null, null, null, null, null, null, null, null, 
1839"\142\157\157\154\145\141\156", "\142\162\145\141\153", "\143\154\141\163\163", "\142\171\164\145", 
1840"\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\157\156\163\164", 
1841"\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", 
1842"\145\154\163\145", "\146\141\154\163\145", "\146\151\156\141\154", 
1843"\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 
1844"\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", 
1845"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\145\167", "\156\165\154\154", 
1846"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
1847"\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", 
1848"\163\167\151\164\143\150", "\164\150\162\157\167", "\164\162\165\145", "\164\162\171", 
1849"\166\157\151\144", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, 
1850null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", 
1851"\75", "\76", "\100\147\164", "\74", "\100\154\164", "\41", "\176", "\77", "\72", 
1852"\75\75", "\74\75", "\100\154\164\145\161", "\76\75", "\100\147\164\145\161", "\41\75", 
1853"\174\174", "\100\157\162", "\46\46", "\100\141\156\144", "\53\53", "\55\55", "\53", 
1854"\55", "\52", "\57", "\46", "\100\142\151\164\167\151\163\145\137\141\156\144", 
1855"\174", "\100\142\151\164\167\151\163\145\137\157\162", "\136", "\45", "\74\74", 
1856"\100\154\145\146\164\137\163\150\151\146\164", "\76\76", "\100\162\151\147\150\164\137\163\150\151\146\164", "\76\76\76", 
1857"\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", 
1858"\100\141\156\144\137\141\163\163\151\147\156", "\174\75", "\100\157\162\137\141\163\163\151\147\156", "\136\75", "\45\75", 
1859"\74\74\75", "\100\154\145\146\164\137\163\150\151\146\164\137\141\163\163\151\147\156", 
1860"\76\76\75", 
1861"\100\162\151\147\150\164\137\163\150\151\146\164\137\141\163\163\151\147\156", "\76\76\76\75", 
1862"\100\162\151\147\150\164\137\165\156\163\151\147\156\145\144\137\163\150\151\146\164\137\141\163\163\151\147\156", };
1863public static final String[] lexStateNames = {
1864   "DEFAULT", 
1865};
1866static final long[] jjtoToken = {
1867   0xe747fffffffff801L, 0x7ffffffffffffffL, 
1868};
1869static final long[] jjtoSkip = {
1870   0x7feL, 0x0L, 
1871};
1872static final long[] jjtoSpecial = {
1873   0x780L, 0x0L, 
1874};
1875private ASCII_UCodeESC_CharStream input_stream;
1876private final int[] jjrounds = new int[74];
1877private final int[] jjstateSet = new int[148];
1878protected char curChar;
1879public ParserTokenManager(ASCII_UCodeESC_CharStream stream)
1880{
1881   if (ASCII_UCodeESC_CharStream.staticFlag)
1882      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1883   input_stream = stream;
1884}
1885public ParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState)
1886{
1887   this(stream);
1888   SwitchTo(lexState);
1889}
1890public void ReInit(ASCII_UCodeESC_CharStream stream)
1891{
1892   jjmatchedPos = jjnewStateCnt = 0;
1893   curLexState = defaultLexState;
1894   input_stream = stream;
1895   ReInitRounds();
1896}
1897private final void ReInitRounds()
1898{
1899   int i;
1900   jjround = 0x80000001;
1901   for (i = 74; i-- > 0;)
1902      jjrounds[i] = 0x80000000;
1903}
1904public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState)
1905{
1906   ReInit(stream);
1907   SwitchTo(lexState);
1908}
1909public void SwitchTo(int lexState)
1910{
1911   if (lexState >= 1 || lexState < 0)
1912      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1913   else
1914      curLexState = lexState;
1915}
1916
1917private final Token jjFillToken()
1918{
1919   Token t = Token.newToken(jjmatchedKind);
1920   t.kind = jjmatchedKind;
1921   String im = jjstrLiteralImages[jjmatchedKind];
1922   t.image = (im == null) ? input_stream.GetImage() : im;
1923   t.beginLine = input_stream.getBeginLine();
1924   t.beginColumn = input_stream.getBeginColumn();
1925   t.endLine = input_stream.getEndLine();
1926   t.endColumn = input_stream.getEndColumn();
1927   return t;
1928}
1929
1930int curLexState = 0;
1931int defaultLexState = 0;
1932int jjnewStateCnt;
1933int jjround;
1934int jjmatchedPos;
1935int jjmatchedKind;
1936
1937public final Token getNextToken() 
1938{
1939  int kind;
1940  Token specialToken = null;
1941  Token matchedToken;
1942  int curPos = 0;
1943
1944  EOFLoop :
1945  for (;;)
1946  {   
1947   try   
1948   {     
1949      curChar = input_stream.BeginToken();
1950   }     
1951   catch(java.io.IOException e)
1952   {        
1953      jjmatchedKind = 0;
1954      matchedToken = jjFillToken();
1955      matchedToken.specialToken = specialToken;
1956      return matchedToken;
1957   }
1958
1959   jjmatchedKind = 0x7fffffff;
1960   jjmatchedPos = 0;
1961   curPos = jjMoveStringLiteralDfa0_0();
1962   if (jjmatchedKind != 0x7fffffff)
1963   {
1964