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