Clover coverage report - PMD - 3.7
Coverage timestamp: Wed May 31 2006 09:25:59 EDT
file stats: LOC: 3,639   Methods: 115
NCLOC: 3,626   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
JspParserTokenManager.java 42.4% 53.1% 60% 50.5%
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  423 private final int jjStopAtPos(int pos, int kind)
 30    {
 31  423 jjmatchedKind = kind;
 32  423 jjmatchedPos = pos;
 33  423 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  3609 private final void jjCheckNAdd(int state)
 72    {
 73  3609 if (jjrounds[state] != jjround)
 74    {
 75  3609 jjstateSet[jjnewStateCnt++] = state;
 76  3609 jjrounds[state] = jjround;
 77    }
 78    }
 79  240 private final void jjAddStates(int start, int end)
 80    {
 81  240 do {
 82  480 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 83  480 } while (start++ != end);
 84    }
 85  219 private final void jjCheckNAddTwoStates(int state1, int state2)
 86    {
 87  219 jjCheckNAdd(state1);
 88  219 jjCheckNAdd(state2);
 89    }
 90  652 private final void jjCheckNAddStates(int start, int end)
 91    {
 92  652 do {
 93  2019 jjCheckNAdd(jjnextStates[start]);
 94  2019 } 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  30 private final int jjMoveStringLiteralDfa0_2()
 553    {
 554  30 switch(curChar)
 555    {
 556  15 case 39:
 557  15 return jjStopAtPos(0, 69);
 558  15 default :
 559  15 return jjMoveNfa_2(9, 0);
 560    }
 561    }
 562  15 private final int jjMoveNfa_2(int startState, int curPos)
 563    {
 564  15 int[] nextStates;
 565  15 int startsAt = 0;
 566  15 jjnewStateCnt = 37;
 567  15 int i = 1;
 568  15 jjstateSet[0] = startState;
 569  15 int j, kind = 0x7fffffff;
 570  15 for (;;)
 571    {
 572  180 if (++jjround == 0x7fffffff)
 573  0 ReInitRounds();
 574  180 if (curChar < 64)
 575    {
 576  35 long l = 1L << curChar;
 577  35 MatchLoop: do
 578    {
 579  119 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  24 case 28:
 690  24 if ((0xffffff67ffffffffL & l) == 0L)
 691  12 break;
 692  12 if (kind > 70)
 693  12 kind = 70;
 694  12 jjCheckNAddStates(2, 4);
 695  12 break;
 696  24 case 29:
 697  24 if ((0x1800000000L & l) != 0L)
 698  0 jjCheckNAdd(30);
 699  24 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  28 default : break;
 724    }
 725  119 } while(i != startsAt);
 726    }
 727  145 else if (curChar < 128)
 728    {
 729  145 long l = 1L << (curChar & 077);
 730  145 MatchLoop: do
 731    {
 732  473 switch(jjstateSet[--i])
 733    {
 734  11 case 9:
 735  11 if (kind > 70)
 736  11 kind = 70;
 737  11 jjCheckNAddStates(2, 4);
 738  11 if (curChar == 92)
 739  0 jjAddStates(16, 17);
 740  11 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  104 case 28:
 782  104 if (kind > 70)
 783  104 kind = 70;
 784  104 jjCheckNAddStates(2, 4);
 785  104 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  104 case 31:
 794  104 if (curChar == 92)
 795  0 jjAddStates(16, 17);
 796  104 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  184 default : break;
 805    }
 806  473 } 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  180 if (kind != 0x7fffffff)
 859    {
 860  131 jjmatchedKind = kind;
 861  131 jjmatchedPos = curPos;
 862  131 kind = 0x7fffffff;
 863    }
 864  180 ++curPos;
 865  ? if ((i = jjnewStateCnt) == (startsAt = 37 - (jjnewStateCnt = startsAt)))
 866  15 return curPos;
 867  165 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  27 private final int jjMoveStringLiteralDfa0_13()
 1151    {
 1152  27 switch(curChar)
 1153    {
 1154  12 case 34:
 1155  12 return jjStopAtPos(0, 65);
 1156  15 case 39:
 1157  15 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  278 private final int jjMoveStringLiteralDfa0_12()
 1551    {
 1552  278 switch(curChar)
 1553    {
 1554  181 case 60:
 1555  181 jjmatchedKind = 22;
 1556  181 return jjMoveStringLiteralDfa1_12(0x1ff800000L);
 1557  97 default :
 1558  97 return jjMoveNfa_12(10, 0);
 1559    }
 1560    }
 1561  181 private final int jjMoveStringLiteralDfa1_12(long active0)
 1562    {
 1563  181 try { curChar = input_stream.readChar(); }
 1564    catch(java.io.IOException e) {
 1565  0 jjStopStringLiteralDfa_12(0, active0);
 1566  0 return 1;
 1567    }
 1568  181 switch(curChar)
 1569    {
 1570  8 case 33:
 1571  8 return jjMoveStringLiteralDfa2_12(active0, 0xd000000L);
 1572  11 case 37:
 1573  11 if ((active0 & 0x80000000L) != 0L)
 1574    {
 1575  11 jjmatchedKind = 31;
 1576  11 jjmatchedPos = 1;
 1577    }
 1578  11 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  19 private final int jjMoveStringLiteralDfa2_12(long old0, long active0)
 1593    {
 1594  19 if (((active0 &= old0)) == 0L)
 1595  0 return jjStartNfa_12(0, old0);
 1596  19 try { curChar = input_stream.readChar(); }
 1597    catch(java.io.IOException e) {
 1598  0 jjStopStringLiteralDfa_12(1, active0);
 1599  0 return 2;
 1600    }
 1601  19 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  5 case 64:
 1614  5 if ((active0 & 0x100000000L) != 0L)
 1615  5 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  167 private final int jjMoveNfa_12(int startState, int curPos)
 1769    {
 1770  167 int[] nextStates;
 1771  167 int startsAt = 0;
 1772  167 jjnewStateCnt = 18;
 1773  167 int i = 1;
 1774  167 jjstateSet[0] = startState;
 1775  167 int j, kind = 0x7fffffff;
 1776  167 for (;;)
 1777    {
 1778  381 if (++jjround == 0x7fffffff)
 1779  0 ReInitRounds();
 1780  381 if (curChar < 64)
 1781    {
 1782  178 long l = 1L << curChar;
 1783  178 MatchLoop: do
 1784    {
 1785  430 switch(jjstateSet[--i])
 1786    {
 1787  75 case 10:
 1788  75 if ((0xefffffefffffffffL & l) != 0L)
 1789    {
 1790  74 if (kind > 34)
 1791  74 kind = 34;
 1792  74 jjCheckNAddStates(31, 33);
 1793    }
 1794  1 else if (curChar == 36)
 1795  1 jjstateSet[jjnewStateCnt++] = 13;
 1796  75 if ((0x100002600L & l) != 0L)
 1797    {
 1798  72 if (kind > 21)
 1799  72 kind = 21;
 1800  72 jjCheckNAdd(0);
 1801    }
 1802  3 else if (curChar == 36)
 1803  1 jjstateSet[jjnewStateCnt++] = 1;
 1804  75 break;
 1805  49 case 0:
 1806  49 if ((0x100002600L & l) == 0L)
 1807  48 break;
 1808  1 if (kind > 21)
 1809  1 kind = 21;
 1810  1 jjCheckNAdd(0);
 1811  1 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  92 case 11:
 1841  92 if ((0xefffffefffffffffL & l) == 0L)
 1842  72 break;
 1843  20 if (kind > 34)
 1844  19 kind = 34;
 1845  20 jjCheckNAddStates(31, 33);
 1846  20 break;
 1847  92 case 12:
 1848  92 if (curChar == 36)
 1849  1 jjstateSet[jjnewStateCnt++] = 13;
 1850  92 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  99 default : break;
 1867    }
 1868  430 } 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  381 if (kind != 0x7fffffff)
 1963    {
 1964  211 jjmatchedKind = kind;
 1965  211 jjmatchedPos = curPos;
 1966  211 kind = 0x7fffffff;
 1967    }
 1968  381 ++curPos;
 1969  ? if ((i = jjnewStateCnt) == (startsAt = 18 - (jjnewStateCnt = startsAt)))
 1970  143 return curPos;
 1971  238 try { curChar = input_stream.readChar(); }
 1972  24 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  278 private final int jjMoveStringLiteralDfa0_11()
 2151    {
 2152  278 switch(curChar)
 2153    {
 2154  6 case 47:
 2155  6 return jjMoveStringLiteralDfa1_11(0x2000000000000000L);
 2156  27 case 61:
 2157  27 return jjStopAtPos(0, 62);
 2158  188 case 62:
 2159  188 return jjStopAtPos(0, 59);
 2160  57 default :
 2161  57 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  57 private final int jjMoveNfa_11(int startState, int curPos)
 2183    {
 2184  57 int[] nextStates;
 2185  57 int startsAt = 0;
 2186  57 jjnewStateCnt = 6;
 2187  57 int i = 1;
 2188  57 jjstateSet[0] = startState;
 2189  57 int j, kind = 0x7fffffff;
 2190  57 for (;;)
 2191    {
 2192  227 if (++jjround == 0x7fffffff)
 2193  0 ReInitRounds();
 2194  227 if (curChar < 64)
 2195    {
 2196  61 long l = 1L << curChar;
 2197  61 MatchLoop: do
 2198    {
 2199  61 switch(jjstateSet[--i])
 2200    {
 2201  30 case 1:
 2202  30 if ((0x100002600L & l) != 0L)
 2203    {
 2204  29 if (kind > 21)
 2205  29 kind = 21;
 2206  29 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  30 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  28 case 2:
 2226  28 if ((0x7ff601000000000L & l) == 0L)
 2227  27 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  61 } while(i != startsAt);
 2247    }
 2248  166 else if (curChar < 128)
 2249    {
 2250  166 long l = 1L << (curChar & 077);
 2251  166 MatchLoop: do
 2252    {
 2253  166 switch(jjstateSet[--i])
 2254    {
 2255  27 case 1:
 2256  112 case 2:
 2257  139 if ((0x7fffffe87fffffeL & l) == 0L)
 2258  0 break;
 2259  139 if (kind > 58)
 2260  139 kind = 58;
 2261  139 jjCheckNAdd(2);
 2262  139 break;
 2263  27 default : break;
 2264    }
 2265  166 } 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  227 if (kind != 0x7fffffff)
 2288    {
 2289  170 jjmatchedKind = kind;
 2290  170 jjmatchedPos = curPos;
 2291  170 kind = 0x7fffffff;
 2292    }
 2293  227 ++curPos;
 2294  ? if ((i = jjnewStateCnt) == (startsAt = 6 - (jjnewStateCnt = startsAt)))
 2295  57 return curPos;
 2296  170 try { curChar = input_stream.readChar(); }
 2297  0 catch(java.io.IOException e) { return curPos; }
 2298    }
 2299    }
 2300  22 private final int jjMoveStringLiteralDfa0_15()
 2301    {
 2302  22 return jjMoveNfa_15(1, 0);
 2303    }
 2304  22 private final int jjMoveNfa_15(int startState, int curPos)
 2305    {
 2306  22 int[] nextStates;
 2307  22 int startsAt = 0;
 2308  22 jjnewStateCnt = 3;
 2309  22 int i = 1;
 2310  22 jjstateSet[0] = startState;
 2311  22 int j, kind = 0x7fffffff;
 2312  22 for (;;)
 2313    {
 2314  77 if (++jjround == 0x7fffffff)
 2315  0 ReInitRounds();
 2316  77 if (curChar < 64)
 2317    {
 2318  22 long l = 1L << curChar;
 2319  22 MatchLoop: do
 2320    {
 2321  22 switch(jjstateSet[--i])
 2322    {
 2323  11 case 1:
 2324  11 if ((0x100002600L & l) != 0L)
 2325    {
 2326  11 if (kind > 20)
 2327  11 kind = 20;
 2328  11 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  11 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  11 case 2:
 2344  11 if ((0x7ff601000000000L & l) == 0L)
 2345  11 break;
 2346  0 if (kind > 35)
 2347  0 kind = 35;
 2348  0 jjCheckNAdd(2);
 2349  0 break;
 2350  0 default : break;
 2351    }
 2352  22 } while(i != startsAt);
 2353    }
 2354  55 else if (curChar < 128)
 2355    {
 2356  55 long l = 1L << (curChar & 077);
 2357  55 MatchLoop: do
 2358    {
 2359  55 switch(jjstateSet[--i])
 2360    {
 2361  11 case 1:
 2362  33 case 2:
 2363  44 if ((0x7fffffe87fffffeL & l) == 0L)
 2364  0 break;
 2365  44 if (kind > 35)
 2366  44 kind = 35;
 2367  44 jjCheckNAdd(2);
 2368  44 break;
 2369  11 default : break;
 2370    }
 2371  55 } 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  77 if (kind != 0x7fffffff)
 2394    {
 2395  55 jjmatchedKind = kind;
 2396  55 jjmatchedPos = curPos;
 2397  55 kind = 0x7fffffff;
 2398    }
 2399  77 ++curPos;
 2400  ? if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
 2401  22 return curPos;
 2402  55 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  59 private final int jjMoveStringLiteralDfa0_14()
 3181    {
 3182  59 switch(curChar)
 3183    {
 3184  11 case 37:
 3185  11 return jjMoveStringLiteralDfa1_14(0x8000000000L);
 3186  12 case 61:
 3187  12 return jjStopAtPos(0, 37);
 3188  36 default :
 3189  36 return jjMoveNfa_14(1, 0);
 3190    }
 3191    }
 3192  11 private final int jjMoveStringLiteralDfa1_14(long active0)
 3193    {
 3194  11 try { curChar = input_stream.readChar(); }
 3195    catch(java.io.IOException e) {
 3196  0 jjStopStringLiteralDfa_14(0, active0);
 3197  0 return 1;
 3198    }
 3199  11 switch(curChar)
 3200    {
 3201  11 case 62:
 3202  11 if ((active0 & 0x8000000000L) != 0L)
 3203  11 return jjStopAtPos(1, 39);
 3204  0 break;
 3205  0 default :
 3206  0 break;
 3207    }
 3208  0 return jjStartNfa_14(0, active0);
 3209    }
 3210  36 private final int jjMoveNfa_14(int startState, int curPos)
 3211    {
 3212  36 int[] nextStates;
 3213  36 int startsAt = 0;
 3214  36 jjnewStateCnt = 9;
 3215  36 int i = 1;
 3216  36 jjstateSet[0] = startState;
 3217  36 int j, kind = 0x7fffffff;
 3218  36 for (;;)
 3219    {
 3220  339 if (++jjround == 0x7fffffff)
 3221  0 ReInitRounds();
 3222  339 if (curChar < 64)
 3223    {
 3224  77 long l = 1L << curChar;
 3225  77 MatchLoop: do
 3226    {
 3227  118 switch(jjstateSet[--i])
 3228    {
 3229  24 case 1:
 3230  24 if ((0x100002600L & l) != 0L)
 3231    {
 3232  12 if (kind > 20)
 3233  12 kind = 20;
 3234  12 jjCheckNAdd(0);
 3235    }
 3236  12 else if (curChar == 34)
 3237  11 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  24 break;
 3247  0 case 0:
 3248  0 if ((0x100002600L & l) == 0L)
 3249  0 break;
 3250  0 if (kind > 20)
 3251  0 kind = 20;
 3252  0 jjCheckNAdd(0);
 3253  0 break;
 3254  12 case 2:
 3255  12 if ((0x7ff601000000000L & l) == 0L)
 3256  12 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  40 case 7:
 3278  40 if ((0xfffffffbffffffffL & l) != 0L)
 3279  29 jjCheckNAddTwoStates(7, 8);
 3280  40 break;
 3281  40 case 8:
 3282  40 if (curChar == 34 && kind > 38)
 3283  11 kind = 38;
 3284  40 break;
 3285  0 default : break;
 3286    }
 3287  118 } while(i != startsAt);
 3288    }
 3289  262 else if (curChar < 128)
 3290    {
 3291  262 long l = 1L << (curChar & 077);
 3292  262 MatchLoop: do
 3293    {
 3294  437 switch(jjstateSet[--i])
 3295    {
 3296  12 case 1:
 3297  63 case 2:
 3298  75 if ((0x7fffffe87fffffeL & l) == 0L)
 3299  0 break;
 3300  75 if (kind > 36)
 3301  75 kind = 36;
 3302  75 jjCheckNAdd(2);
 3303  75 break;
 3304  4 case 4:
 3305  4 jjAddStates(38, 39);
 3306  4 break;
 3307  171 case 7:
 3308  171 jjAddStates(40, 41);
 3309  171 break;
 3310  187 default : break;
 3311    }
 3312  437 } 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  339 if (kind != 0x7fffffff)
 3343    {
 3344  99 jjmatchedKind = kind;
 3345  99 jjmatchedPos = curPos;
 3346  99 kind = 0x7fffffff;
 3347    }
 3348  339 ++curPos;
 3349  ? if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
 3350  36 return curPos;
 3351  303 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  1543 public Token getNextToken()
 3461    {
 3462  1543 int kind;
 3463  1543 Token specialToken = null;
 3464  1543 Token matchedToken;
 3465  1543 int curPos = 0;
 3466   
 3467  1543 EOFLoop :
 3468    for (;;)
 3469    {
 3470  1664 try
 3471    {
 3472  1664 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  1625 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  30 case 2:
 3499  30 jjmatchedKind = 0x7fffffff;
 3500  30 jjmatchedPos = 0;
 3501  30 curPos = jjMoveStringLiteralDfa0_2();
 3502  30 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  278 case 11:
 3552  278 jjmatchedKind = 0x7fffffff;
 3553  278 jjmatchedPos = 0;
 3554  278 curPos = jjMoveStringLiteralDfa0_11();
 3555  278 if (jjmatchedPos == 0 && jjmatchedKind > 63)
 3556    {
 3557  0 jjmatchedKind = 63;
 3558    }
 3559  278 break;
 3560  278 case 12:
 3561  278 jjmatchedKind = 0x7fffffff;
 3562  278 jjmatchedPos = 0;
 3563  278 curPos = jjMoveStringLiteralDfa0_12();
 3564  278 break;
 3565  27 case 13:
 3566  27 jjmatchedKind = 0x7fffffff;
 3567  27 jjmatchedPos = 0;
 3568  27 curPos = jjMoveStringLiteralDfa0_13();
 3569  27 break;
 3570  59 case 14:
 3571  59 jjmatchedKind = 0x7fffffff;
 3572  59 jjmatchedPos = 0;
 3573  59 curPos = jjMoveStringLiteralDfa0_14();
 3574  59 break;
 3575  22 case 15:
 3576  22 jjmatchedKind = 0x7fffffff;
 3577  22 jjmatchedPos = 0;
 3578  22 curPos = jjMoveStringLiteralDfa0_15();
 3579  22 break;
 3580  39 case 16:
 3581  39 jjmatchedKind = 0x7fffffff;
 3582  39 jjmatchedPos = 0;
 3583  39 curPos = jjMoveStringLiteralDfa0_16();
 3584  39 break;
 3585    }
 3586  1625 if (jjmatchedKind != 0x7fffffff)
 3587    {
 3588  1625 if (jjmatchedPos + 1 < curPos)
 3589  511 input_stream.backup(curPos - jjmatchedPos - 1);
 3590  1625 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 3591    {
 3592  1504 matchedToken = jjFillToken();
 3593  1504 matchedToken.specialToken = specialToken;
 3594  1504 if (jjnewLexState[jjmatchedKind] != -1)
 3595  728 curLexState = jjnewLexState[jjmatchedKind];
 3596  1504 return matchedToken;
 3597    }
 3598    else
 3599    {
 3600  121 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 3601    {
 3602  98 matchedToken = jjFillToken();
 3603  98 if (specialToken == null)
 3604  98 specialToken = matchedToken;
 3605    else
 3606    {
 3607  0 matchedToken.specialToken = specialToken;
 3608  0 specialToken = (specialToken.next = matchedToken);
 3609    }
 3610    }
 3611  121 if (jjnewLexState[jjmatchedKind] != -1)
 3612  0 curLexState = jjnewLexState[jjmatchedKind];
 3613  121 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    }