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