View Javadoc

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