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