0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JSParserTokenManager.java */
0002 package org.descripter.js.parse;
0003 
0004 /** Token Manager. */
0005 public class JSParserTokenManager implements JSParserConstants
0006 {
0007 
0008   /** Debug output. */
0009   public  java.io.PrintStream debugStream = System.out;
0010   /** Set debug output. */
0011   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
0012 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2)
0013 {
0014    switch (pos)
0015    {
0016       case 0:
0017          if ((active0 & 0x48800100000L) != 0L)
0018          {
0019             jjmatchedKind = 113;
0020             return 6;
0021          }
0022          if ((active0 & 0x373bbee0000L) != 0L || (active1 & 0x8000000L) != 0L)
0023          {
0024             jjmatchedKind = 113;
0025             return 106;
0026          }
0027          if ((active0 & 0x2000000000000L) != 0L)
0028             return 13;
0029          if ((active0 & 0x3000L) != 0L || (active1 & 0x6000000L) != 0L)
0030             return 67;
0031          if ((active0 & 0x444000000L) != 0L)
0032          {
0033             jjmatchedKind = 113;
0034             return 10;
0035          }
0036          return -1;
0037       case 1:
0038          if ((active0 & 0x1bbfff20000L) != 0L)
0039          {
0040             if (jjmatchedPos != 1)
0041             {
0042                jjmatchedKind = 113;
0043                jjmatchedPos = 1;
0044             }
0045             return 106;
0046          }
0047          if ((active0 & 0x400000000L) != 0L || (active1 & 0x8000000L) != 0L)
0048          {
0049             if (jjmatchedPos != 1)
0050             {
0051                jjmatchedKind = 113;
0052                jjmatchedPos = 1;
0053             }
0054             return 53;
0055          }
0056          if ((active1 & 0x4000000L) != 0L)
0057             return 107;
0058          if ((active0 & 0x240000c0000L) != 0L)
0059             return 106;
0060          if ((active0 & 0x40000000000L) != 0L)
0061          {
0062             if (jjmatchedPos != 1)
0063             {
0064                jjmatchedKind = 113;
0065                jjmatchedPos = 1;
0066             }
0067             return 5;
0068          }
0069          return -1;
0070       case 2:
0071          if ((active0 & 0x1bfbe7a0000L) != 0L || (active1 & 0x8000000L) != 0L)
0072          {
0073             if (jjmatchedPos != 2)
0074             {
0075                jjmatchedKind = 113;
0076                jjmatchedPos = 2;
0077             }
0078             return 106;
0079          }
0080          if ((active0 & 0x40041800000L) != 0L)
0081             return 106;
0082          return -1;
0083       case 3:
0084          if ((active0 & 0x208000000L) != 0L)
0085          {
0086             jjmatchedKind = 113;
0087             jjmatchedPos = 3;
0088             return 53;
0089          }
0090          if ((active0 & 0x1a5a61a0000L) != 0L)
0091          {
0092             jjmatchedKind = 113;
0093             jjmatchedPos = 3;
0094             return 106;
0095          }
0096          if ((active0 & 0x1810600000L) != 0L || (active1 & 0x8000000L) != 0L)
0097             return 106;
0098          return -1;
0099       case 4:
0100          if ((active0 & 0x106ac180000L) != 0L)
0101          {
0102             jjmatchedKind = 113;
0103             jjmatchedPos = 4;
0104             return 106;
0105          }
0106          if ((active0 & 0x2000000000L) != 0L)
0107          {
0108             jjmatchedKind = 113;
0109             jjmatchedPos = 4;
0110             return 53;
0111          }
0112          if ((active0 & 0x8102020000L) != 0L)
0113             return 106;
0114          return -1;
0115       case 5:
0116          if ((active0 & 0x2624080000L) != 0L)
0117          {
0118             jjmatchedKind = 113;
0119             jjmatchedPos = 5;
0120             return 106;
0121          }
0122          if ((active0 & 0x10088100000L) != 0L)
0123             return 106;
0124          return -1;
0125       case 6:
0126          if ((active0 & 0x20000000L) != 0L)
0127          {
0128             jjmatchedKind = 113;
0129             jjmatchedPos = 6;
0130             return 53;
0131          }
0132          if ((active0 & 0x600080000L) != 0L)
0133          {
0134             jjmatchedKind = 113;
0135             jjmatchedPos = 6;
0136             return 106;
0137          }
0138          if ((active0 & 0x2004000000L) != 0L)
0139             return 106;
0140          return -1;
0141       case 7:
0142          if ((active0 & 0x20000000L) != 0L)
0143             return 54;
0144          if ((active0 & 0x80000L) != 0L)
0145          {
0146             jjmatchedKind = 113;
0147             jjmatchedPos = 7;
0148             return 106;
0149          }
0150          if ((active0 & 0x600000000L) != 0L)
0151             return 106;
0152          return -1;
0153       case 8:
0154          if ((active0 & 0x80000L) != 0L)
0155          {
0156             jjmatchedKind = 113;
0157             jjmatchedPos = 8;
0158             return 106;
0159          }
0160          return -1;
0161       default :
0162          return -1;
0163    }
0164 }
0165 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
0166 {
0167    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
0168 }
0169 private int jjStopAtPos(int pos, int kind)
0170 {
0171    jjmatchedKind = kind;
0172    jjmatchedPos = pos;
0173    return pos + 1;
0174 }
0175 private int jjMoveStringLiteralDfa0_0()
0176 {
0177    switch(curChar)
0178    {
0179       case 10:
0180          return jjStopAtPos(0, 8);
0181       case 11:
0182          return jjStopAtPos(0, 2);
0183       case 13:
0184          return jjStopAtPos(0, 9);
0185       case 33:
0186          jjmatchedKind = 72;
0187          return jjMoveStringLiteralDfa1_0(0xa00000000000000L, 0x0L);
0188       case 35:
0189          return jjStopAtPos(0, 128);
0190       case 37:
0191          jjmatchedKind = 63;
0192          return jjMoveStringLiteralDfa1_0(0x0L, 0x40000L);
0193       case 38:
0194          jjmatchedKind = 69;
0195          return jjMoveStringLiteralDfa1_0(0x0L, 0x400400L);
0196       case 40:
0197          return jjStopAtPos(0, 45);
0198       case 41:
0199          return jjStopAtPos(0, 46);
0200       case 42:
0201          jjmatchedKind = 62;
0202          return jjMoveStringLiteralDfa1_0(0x0L, 0x20000L);
0203       case 43:
0204          jjmatchedKind = 60;
0205          return jjMoveStringLiteralDfa1_0(0x0L, 0x8001L);
0206       case 44:
0207          return jjStopAtPos(0, 51);
0208       case 45:
0209          jjmatchedKind = 61;
0210          return jjMoveStringLiteralDfa1_0(0x0L, 0x10002L);
0211       case 46:
0212          return jjStartNfaWithStates_0(0, 49, 13);
0213       case 47:
0214          jjmatchedKind = 89;
0215          return jjMoveStringLiteralDfa1_0(0x3000L, 0x4000000L);
0216       case 58:
0217          return jjStopAtPos(0, 77);
0218       case 59:
0219          return jjStopAtPos(0, 50);
0220       case 60:
0221          jjmatchedKind = 52;
0222          return jjMoveStringLiteralDfa1_0(0x40000000000000L, 0x80004L);
0223       case 61:
0224          jjmatchedKind = 78;
0225          return jjMoveStringLiteralDfa1_0(0x500000000000000L, 0x0L);
0226       case 62:
0227          jjmatchedKind = 53;
0228          return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x300018L);
0229       case 63:
0230          return jjStopAtPos(0, 76);
0231       case 91:
0232          return jjStopAtPos(0, 47);
0233       case 93:
0234          return jjStopAtPos(0, 48);
0235       case 94:
0236          jjmatchedKind = 71;
0237          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000L);
0238       case 98:
0239          return jjMoveStringLiteralDfa1_0(0x20000L, 0x0L);
0240       case 99:
0241          return jjMoveStringLiteralDfa1_0(0x22200000L, 0x0L);
0242       case 100:
0243          return jjMoveStringLiteralDfa1_0(0x12200040000L, 0x0L);
0244       case 101:
0245          return jjMoveStringLiteralDfa1_0(0x400000L, 0x0L);
0246       case 102:
0247          return jjMoveStringLiteralDfa1_0(0x444000000L, 0x0L);
0248       case 105:
0249          return jjMoveStringLiteralDfa1_0(0x24000080000L, 0x0L);
0250       case 110:
0251          return jjMoveStringLiteralDfa1_0(0x800000L, 0x8000000L);
0252       case 114:
0253          return jjMoveStringLiteralDfa1_0(0x8000000L, 0x0L);
0254       case 115:
0255          return jjMoveStringLiteralDfa1_0(0x80000000L, 0x0L);
0256       case 116:
0257          return jjMoveStringLiteralDfa1_0(0x48800100000L, 0x0L);
0258       case 118:
0259          return jjMoveStringLiteralDfa1_0(0x11000000L, 0x0L);
0260       case 119:
0261          return jjMoveStringLiteralDfa1_0(0x1100000000L, 0x0L);
0262       case 123:
0263          return jjStopAtPos(0, 43);
0264       case 124:
0265          jjmatchedKind = 70;
0266          return jjMoveStringLiteralDfa1_0(0x0L, 0x800800L);
0267       case 125:
0268          return jjStopAtPos(0, 44);
0269       case 126:
0270          return jjStopAtPos(0, 73);
0271       case 160:
0272          return jjStopAtPos(0, 5);
0273       case 8232:
0274          return jjStopAtPos(0, 10);
0275       case 8233:
0276          return jjStopAtPos(0, 11);
0277       case 65279:
0278          return jjStopAtPos(0, 6);
0279       default :
0280          return jjMoveNfa_0(0, 0);
0281    }
0282 }
0283 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
0284 {
0285    try { curChar = input_stream.readChar(); }
0286    catch(java.io.IOException e) {
0287       jjStopStringLiteralDfa_0(0, active0, active1, 0L);
0288       return 1;
0289    }
0290    switch(curChar)
0291    {
0292       case 38:
0293          if ((active1 & 0x400L) != 0L)
0294             return jjStopAtPos(1, 74);
0295          break;
0296       case 42:
0297          if ((active0 & 0x2000L) != 0L)
0298             return jjStopAtPos(1, 13);
0299          break;
0300       case 43:
0301          if ((active1 & 0x1L) != 0L)
0302             return jjStopAtPos(1, 64);
0303          break;
0304       case 45:
0305          if ((active1 & 0x2L) != 0L)
0306             return jjStopAtPos(1, 65);
0307          break;
0308       case 47:
0309          if ((active0 & 0x1000L) != 0L)
0310             return jjStopAtPos(1, 12);
0311          break;
0312       case 60:
0313          if ((active1 & 0x4L) != 0L)
0314          {
0315             jjmatchedKind = 66;
0316             jjmatchedPos = 1;
0317          }
0318          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000L);
0319       case 61:
0320          if ((active0 & 0x40000000000000L) != 0L)
0321             return jjStopAtPos(1, 54);
0322          else if ((active0 & 0x80000000000000L) != 0L)
0323             return jjStopAtPos(1, 55);
0324          else if ((active0 & 0x100000000000000L) != 0L)
0325          {
0326             jjmatchedKind = 56;
0327             jjmatchedPos = 1;
0328          }
0329          else if ((active0 & 0x200000000000000L) != 0L)
0330          {
0331             jjmatchedKind = 57;
0332             jjmatchedPos = 1;
0333          }
0334          else if ((active1 & 0x8000L) != 0L)
0335             return jjStopAtPos(1, 79);
0336          else if ((active1 & 0x10000L) != 0L)
0337             return jjStopAtPos(1, 80);
0338          else if ((active1 & 0x20000L) != 0L)
0339             return jjStopAtPos(1, 81);
0340          else if ((active1 & 0x40000L) != 0L)
0341             return jjStopAtPos(1, 82);
0342          else if ((active1 & 0x400000L) != 0L)
0343             return jjStopAtPos(1, 86);
0344          else if ((active1 & 0x800000L) != 0L)
0345             return jjStopAtPos(1, 87);
0346          else if ((active1 & 0x1000000L) != 0L)
0347             return jjStopAtPos(1, 88);
0348          else if ((active1 & 0x4000000L) != 0L)
0349             return jjStartNfaWithStates_0(1, 90, 107);
0350          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000000000L, active1, 0L);
0351       case 62:
0352          if ((active1 & 0x8L) != 0L)
0353          {
0354             jjmatchedKind = 67;
0355             jjmatchedPos = 1;
0356          }
0357          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300010L);
0358       case 97:
0359          return jjMoveStringLiteralDfa2_0(active0, 0x3200000L, active1, 0L);
0360       case 101:
0361          return jjMoveStringLiteralDfa2_0(active0, 0x12208800000L, active1, 0L);
0362       case 102:
0363          if ((active0 & 0x4000000000L) != 0L)
0364             return jjStartNfaWithStates_0(1, 38, 106);
0365          break;
0366       case 104:
0367          return jjMoveStringLiteralDfa2_0(active0, 0x8900000000L, active1, 0L);
0368       case 105:
0369          return jjMoveStringLiteralDfa2_0(active0, 0x1004000000L, active1, 0L);
0370       case 108:
0371          return jjMoveStringLiteralDfa2_0(active0, 0x400000L, active1, 0L);
0372       case 110:
0373          if ((active0 & 0x20000000000L) != 0L)
0374          {
0375             jjmatchedKind = 41;
0376             jjmatchedPos = 1;
0377          }
0378          return jjMoveStringLiteralDfa2_0(active0, 0x80000L, active1, 0L);
0379       case 111:
0380          if ((active0 & 0x40000L) != 0L)
0381             return jjStartNfaWithStates_0(1, 18, 106);
0382          return jjMoveStringLiteralDfa2_0(active0, 0x70000000L, active1, 0L);
0383       case 114:
0384          return jjMoveStringLiteralDfa2_0(active0, 0x40000020000L, active1, 0L);
0385       case 117:
0386          return jjMoveStringLiteralDfa2_0(active0, 0x400000000L, active1, 0x8000000L);
0387       case 119:
0388          return jjMoveStringLiteralDfa2_0(active0, 0x80000000L, active1, 0L);
0389       case 121:
0390          return jjMoveStringLiteralDfa2_0(active0, 0x100000L, active1, 0L);
0391       case 124:
0392          if ((active1 & 0x800L) != 0L)
0393             return jjStopAtPos(1, 75);
0394          break;
0395       default :
0396          break;
0397    }
0398    return jjStartNfa_0(0, active0, active1, 0L);
0399 }
0400 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
0401 {
0402    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0403       return jjStartNfa_0(0, old0, old1, 0L);
0404    try { curChar = input_stream.readChar(); }
0405    catch(java.io.IOException e) {
0406       jjStopStringLiteralDfa_0(1, active0, active1, 0L);
0407       return 2;
0408    }
0409    switch(curChar)
0410    {
0411       case 61:
0412          if ((active0 & 0x400000000000000L) != 0L)
0413             return jjStopAtPos(2, 58);
0414          else if ((active0 & 0x800000000000000L) != 0L)
0415             return jjStopAtPos(2, 59);
0416          else if ((active1 & 0x80000L) != 0L)
0417             return jjStopAtPos(2, 83);
0418          else if ((active1 & 0x100000L) != 0L)
0419             return jjStopAtPos(2, 84);
0420          break;
0421       case 62:
0422          if ((active1 & 0x10L) != 0L)
0423          {
0424             jjmatchedKind = 68;
0425             jjmatchedPos = 2;
0426          }
0427          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000L);
0428       case 98:
0429          return jjMoveStringLiteralDfa3_0(active0, 0x200000000L, active1, 0L);
0430       case 101:
0431          return jjMoveStringLiteralDfa3_0(active0, 0x20000L, active1, 0L);
0432       case 102:
0433          return jjMoveStringLiteralDfa3_0(active0, 0x2000000000L, active1, 0L);
0434       case 105:
0435          return jjMoveStringLiteralDfa3_0(active0, 0x990000000L, active1, 0L);
0436       case 108:
0437          return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L, active1, 0x8000000L);
0438       case 110:
0439          return jjMoveStringLiteralDfa3_0(active0, 0x424000000L, active1, 0L);
0440       case 112:
0441          return jjMoveStringLiteralDfa3_0(active0, 0x100000L, active1, 0L);
0442       case 114:
0443          if ((active0 & 0x1000000L) != 0L)
0444             return jjStartNfaWithStates_0(2, 24, 106);
0445          else if ((active0 & 0x40000000L) != 0L)
0446             return jjStartNfaWithStates_0(2, 30, 106);
0447          return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L, active1, 0L);
0448       case 115:
0449          return jjMoveStringLiteralDfa3_0(active0, 0x680000L, active1, 0L);
0450       case 116:
0451          return jjMoveStringLiteralDfa3_0(active0, 0x100a000000L, active1, 0L);
0452       case 119:
0453          if ((active0 & 0x800000L) != 0L)
0454             return jjStartNfaWithStates_0(2, 23, 106);
0455          break;
0456       case 121:
0457          if ((active0 & 0x40000000000L) != 0L)
0458             return jjStartNfaWithStates_0(2, 42, 106);
0459          break;
0460       default :
0461          break;
0462    }
0463    return jjStartNfa_0(1, active0, active1, 0L);
0464 }
0465 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
0466 {
0467    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0468       return jjStartNfa_0(1, old0, old1, 0L);
0469    try { curChar = input_stream.readChar(); }
0470    catch(java.io.IOException e) {
0471       jjStopStringLiteralDfa_0(2, active0, active1, 0L);
0472       return 3;
0473    }
0474    switch(curChar)
0475    {
0476       case 61:
0477          if ((active1 & 0x200000L) != 0L)
0478             return jjStopAtPos(3, 85);
0479          break;
0480       case 97:
0481          return jjMoveStringLiteralDfa4_0(active0, 0x2004020000L, active1, 0L);
0482       case 99:
0483          return jjMoveStringLiteralDfa4_0(active0, 0x402000000L, active1, 0L);
0484       case 100:
0485          if ((active0 & 0x10000000L) != 0L)
0486             return jjStartNfaWithStates_0(3, 28, 106);
0487          break;
0488       case 101:
0489          if ((active0 & 0x200000L) != 0L)
0490             return jjStartNfaWithStates_0(3, 21, 106);
0491          else if ((active0 & 0x400000L) != 0L)
0492             return jjStartNfaWithStates_0(3, 22, 106);
0493          return jjMoveStringLiteralDfa4_0(active0, 0x10000100000L, active1, 0L);
0494       case 104:
0495          if ((active0 & 0x1000000000L) != 0L)
0496             return jjStartNfaWithStates_0(3, 36, 106);
0497          break;
0498       case 108:
0499          if ((active1 & 0x8000000L) != 0L)
0500             return jjStartNfaWithStates_0(3, 91, 106);
0501          return jjMoveStringLiteralDfa4_0(active0, 0x100000000L, active1, 0L);
0502       case 111:
0503          return jjMoveStringLiteralDfa4_0(active0, 0x8000000000L, active1, 0L);
0504       case 115:
0505          if ((active0 & 0x800000000L) != 0L)
0506             return jjStartNfaWithStates_0(3, 35, 106);
0507          break;
0508       case 116:
0509          return jjMoveStringLiteralDfa4_0(active0, 0xa0080000L, active1, 0L);
0510       case 117:
0511          return jjMoveStringLiteralDfa4_0(active0, 0x208000000L, active1, 0L);
0512       default :
0513          break;
0514    }
0515    return jjStartNfa_0(2, active0, active1, 0L);
0516 }
0517 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
0518 {
0519    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0520       return jjStartNfa_0(2, old0, old1, 0L);
0521    try { curChar = input_stream.readChar(); }
0522    catch(java.io.IOException e) {
0523       jjStopStringLiteralDfa_0(3, active0, 0L, 0L);
0524       return 4;
0525    }
0526    switch(curChar)
0527    {
0528       case 97:
0529          return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
0530       case 99:
0531          return jjMoveStringLiteralDfa5_0(active0, 0x80000000L);
0532       case 101:
0533          if ((active0 & 0x100000000L) != 0L)
0534             return jjStartNfaWithStates_0(4, 32, 106);
0535          break;
0536       case 103:
0537          return jjMoveStringLiteralDfa5_0(active0, 0x200000000L);
0538       case 104:
0539          if ((active0 & 0x2000000L) != 0L)
0540             return jjStartNfaWithStates_0(4, 25, 106);
0541          break;
0542       case 105:
0543          return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
0544       case 107:
0545          if ((active0 & 0x20000L) != 0L)
0546             return jjStartNfaWithStates_0(4, 17, 106);
0547          break;
0548       case 108:
0549          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
0550       case 111:
0551          return jjMoveStringLiteralDfa5_0(active0, 0x100000L);
0552       case 114:
0553          return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
0554       case 116:
0555          return jjMoveStringLiteralDfa5_0(active0, 0x10400000000L);
0556       case 117:
0557          return jjMoveStringLiteralDfa5_0(active0, 0x2000000000L);
0558       case 119:
0559          if ((active0 & 0x8000000000L) != 0L)
0560             return jjStartNfaWithStates_0(4, 39, 106);
0561          break;
0562       default :
0563          break;
0564    }
0565    return jjStartNfa_0(3, active0, 0L, 0L);
0566 }
0567 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
0568 {
0569    if (((active0 &= old0)) == 0L)
0570       return jjStartNfa_0(3, old0, 0L, 0L);
0571    try { curChar = input_stream.readChar(); }
0572    catch(java.io.IOException e) {
0573       jjStopStringLiteralDfa_0(4, active0, 0L, 0L);
0574       return 5;
0575    }
0576    switch(curChar)
0577    {
0578       case 101:
0579          if ((active0 & 0x10000000000L) != 0L)
0580             return jjStartNfaWithStates_0(5, 40, 106);
0581          break;
0582       case 102:
0583          if ((active0 & 0x100000L) != 0L)
0584             return jjStartNfaWithStates_0(5, 20, 106);
0585          break;
0586       case 103:
0587          return jjMoveStringLiteralDfa6_0(active0, 0x200000000L);
0588       case 104:
0589          if ((active0 & 0x80000000L) != 0L)
0590             return jjStartNfaWithStates_0(5, 31, 106);
0591          break;
0592       case 105:
0593          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
0594       case 108:
0595          return jjMoveStringLiteralDfa6_0(active0, 0x2004000000L);
0596       case 110:
0597          if ((active0 & 0x8000000L) != 0L)
0598             return jjStartNfaWithStates_0(5, 27, 106);
0599          return jjMoveStringLiteralDfa6_0(active0, 0x20080000L);
0600       default :
0601          break;
0602    }
0603    return jjStartNfa_0(4, active0, 0L, 0L);
0604 }
0605 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
0606 {
0607    if (((active0 &= old0)) == 0L)
0608       return jjStartNfa_0(4, old0, 0L, 0L);
0609    try { curChar = input_stream.readChar(); }
0610    catch(java.io.IOException e) {
0611       jjStopStringLiteralDfa_0(5, active0, 0L, 0L);
0612       return 6;
0613    }
0614    switch(curChar)
0615    {
0616       case 99:
0617          return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
0618       case 101:
0619          return jjMoveStringLiteralDfa7_0(active0, 0x200000000L);
0620       case 111:
0621          return jjMoveStringLiteralDfa7_0(active0, 0x400000000L);
0622       case 116:
0623          if ((active0 & 0x2000000000L) != 0L)
0624             return jjStartNfaWithStates_0(6, 37, 106);
0625          break;
0626       case 117:
0627          return jjMoveStringLiteralDfa7_0(active0, 0x20000000L);
0628       case 121:
0629          if ((active0 & 0x4000000L) != 0L)
0630             return jjStartNfaWithStates_0(6, 26, 106);
0631          break;
0632       default :
0633          break;
0634    }
0635    return jjStartNfa_0(5, active0, 0L, 0L);
0636 }
0637 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
0638 {
0639    if (((active0 &= old0)) == 0L)
0640       return jjStartNfa_0(5, old0, 0L, 0L);
0641    try { curChar = input_stream.readChar(); }
0642    catch(java.io.IOException e) {
0643       jjStopStringLiteralDfa_0(6, active0, 0L, 0L);
0644       return 7;
0645    }
0646    switch(curChar)
0647    {
0648       case 101:
0649          if ((active0 & 0x20000000L) != 0L)
0650             return jjStartNfaWithStates_0(7, 29, 54);
0651          return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
0652       case 110:
0653          if ((active0 & 0x400000000L) != 0L)
0654             return jjStartNfaWithStates_0(7, 34, 106);
0655          break;
0656       case 114:
0657          if ((active0 & 0x200000000L) != 0L)
0658             return jjStartNfaWithStates_0(7, 33, 106);
0659          break;
0660       default :
0661          break;
0662    }
0663    return jjStartNfa_0(6, active0, 0L, 0L);
0664 }
0665 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
0666 {
0667    if (((active0 &= old0)) == 0L)
0668       return jjStartNfa_0(6, old0, 0L, 0L);
0669    try { curChar = input_stream.readChar(); }
0670    catch(java.io.IOException e) {
0671       jjStopStringLiteralDfa_0(7, active0, 0L, 0L);
0672       return 8;
0673    }
0674    switch(curChar)
0675    {
0676       case 111:
0677          return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
0678       default :
0679          break;
0680    }
0681    return jjStartNfa_0(7, active0, 0L, 0L);
0682 }
0683 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
0684 {
0685    if (((active0 &= old0)) == 0L)
0686       return jjStartNfa_0(7, old0, 0L, 0L);
0687    try { curChar = input_stream.readChar(); }
0688    catch(java.io.IOException e) {
0689       jjStopStringLiteralDfa_0(8, active0, 0L, 0L);
0690       return 9;
0691    }
0692    switch(curChar)
0693    {
0694       case 102:
0695          if ((active0 & 0x80000L) != 0L)
0696             return jjStartNfaWithStates_0(9, 19, 106);
0697          break;
0698       default :
0699          break;
0700    }
0701    return jjStartNfa_0(8, active0, 0L, 0L);
0702 }
0703 private int jjStartNfaWithStates_0(int pos, int kind, int state)
0704 {
0705    jjmatchedKind = kind;
0706    jjmatchedPos = pos;
0707    try { curChar = input_stream.readChar(); }
0708    catch(java.io.IOException e) { return pos + 1; }
0709    return jjMoveNfa_0(state, pos + 1);
0710 }
0711 static final long[] jjbitVec0 = {
0712    0x0L, 0x0L, 0x1L, 0x0L
0713 };
0714 static final long[] jjbitVec1 = {
0715    0x4000L, 0x0L, 0x0L, 0x0L
0716 };
0717 static final long[] jjbitVec2 = {
0718    0x800000000fffL, 0x80000000L, 0x0L, 0x0L
0719 };
0720 static final long[] jjbitVec3 = {
0721    0x1L, 0x0L, 0x0L, 0x0L
0722 };
0723 static final long[] jjbitVec4 = {
0724    0xfffffffefffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
0725 };
0726 static final long[] jjbitVec6 = {
0727    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
0728 };
0729 static final long[] jjbitVec7 = {
0730    0xfffffcffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
0731 };
0732 static final long[] jjbitVec8 = {
0733    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
0734 };
0735 static final long[] jjbitVec9 = {
0736    0x30000000000L, 0x0L, 0x0L, 0x0L
0737 };
0738 static final long[] jjbitVec10 = {
0739    0x200002L, 0x0L, 0xf00000000L, 0x1200000000000000L
0740 };
0741 static final long[] jjbitVec11 = {
0742    0x10000000000000L, 0x4000L, 0x100000000000L, 0x0L
0743 };
0744 static final long[] jjbitVec12 = {
0745    0x0L, 0x0L, 0x420040000000000L, 0xff7fffffff7fffffL
0746 };
0747 static final long[] jjbitVec13 = {
0748    0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
0749 };
0750 static final long[] jjbitVec14 = {
0751    0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
0752 };
0753 static final long[] jjbitVec15 = {
0754    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
0755 };
0756 static final long[] jjbitVec16 = {
0757    0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
0758 };
0759 static final long[] jjbitVec17 = {
0760    0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
0761 };
0762 static final long[] jjbitVec18 = {
0763    0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
0764 };
0765 static final long[] jjbitVec19 = {
0766    0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
0767 };
0768 static final long[] jjbitVec20 = {
0769    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
0770 };
0771 static final long[] jjbitVec21 = {
0772    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
0773 };
0774 static final long[] jjbitVec22 = {
0775    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
0776 };
0777 static final long[] jjbitVec23 = {
0778    0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
0779 };
0780 static final long[] jjbitVec24 = {
0781    0xdfffffffffffeL, 0x7fL, 0xe00decaefef02596L, 0x3000005fL
0782 };
0783 static final long[] jjbitVec25 = {
0784    0x1L, 0x7ffffffffffL, 0xf00L, 0x0L
0785 };
0786 static final long[] jjbitVec26 = {
0787    0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
0788 };
0789 static final long[] jjbitVec27 = {
0790    0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
0791 };
0792 static final long[] jjbitVec28 = {
0793    0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
0794 };
0795 static final long[] jjbitVec29 = {
0796    0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
0797 };
0798 static final long[] jjbitVec30 = {
0799    0xffffffffffffffffL, 0x7fffffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
0800 };
0801 static final long[] jjbitVec31 = {
0802    0x0L, 0x0L, 0xfffffffffffffL, 0x0L
0803 };
0804 static final long[] jjbitVec32 = {
0805    0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
0806 };
0807 static final long[] jjbitVec33 = {
0808    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
0809 };
0810 static final long[] jjbitVec34 = {
0811    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
0812 };
0813 static final long[] jjbitVec35 = {
0814    0x0L, 0x8000000000000000L, 0x0L, 0x0L
0815 };
0816 static final long[] jjbitVec36 = {
0817    0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
0818 };
0819 static final long[] jjbitVec37 = {
0820    0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x77ffffffffffffffL
0821 };
0822 static final long[] jjbitVec38 = {
0823    0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
0824 };
0825 static final long[] jjbitVec39 = {
0826    0x0L, 0x0L, 0x20000000000000L, 0x0L
0827 };
0828 static final long[] jjbitVec40 = {
0829    0x0L, 0x0L, 0x2000000000L, 0x0L
0830 };
0831 static final long[] jjbitVec41 = {
0832    0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
0833 };
0834 static final long[] jjbitVec42 = {
0835    0x0L, 0x0L, 0x800000000L, 0x0L
0836 };
0837 static final long[] jjbitVec43 = {
0838    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
0839 };
0840 static final long[] jjbitVec44 = {
0841    0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
0842 };
0843 static final long[] jjbitVec45 = {
0844    0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
0845 };
0846 static final long[] jjbitVec46 = {
0847    0x0L, 0xffd7000000000000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
0848 };
0849 static final long[] jjbitVec47 = {
0850    0x7fffffe00000000L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0x1cfcfcfcL
0851 };
0852 static final long[] jjbitVec48 = {
0853    0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
0854 };
0855 static final long[] jjbitVec49 = {
0856    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
0857 };
0858 static final long[] jjbitVec50 = {
0859    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
0860 };
0861 static final long[] jjbitVec51 = {
0862    0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
0863 };
0864 static final long[] jjbitVec52 = {
0865    0xffff1fffffff0000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
0866 };
0867 static final long[] jjbitVec53 = {
0868    0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xf3c5fdfffff99feeL, 0x3ffcfb080399fL
0869 };
0870 static final long[] jjbitVec54 = {
0871    0xd36dfdfffff987ecL, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
0872 };
0873 static final long[] jjbitVec55 = {
0874    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
0875 };
0876 static final long[] jjbitVec56 = {
0877    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
0878 };
0879 static final long[] jjbitVec57 = {
0880    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
0881 };
0882 static final long[] jjbitVec58 = {
0883    0x7fffffffffffffeL, 0x3ff7fffL, 0xfbffecaefef02596L, 0x33ff3f5fL
0884 };
0885 static final long[] jjbitVec59 = {
0886    0xc2a003ff03000001L, 0xfffe07ffffffffffL, 0x1ffffffffeff0fdfL, 0x40L
0887 };
0888 static final long[] jjbitVec60 = {
0889    0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
0890 };
0891 static final long[] jjbitVec61 = {
0892    0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
0893 };
0894 static final long[] jjbitVec62 = {
0895    0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff000fffffL
0896 };
0897 static final long[] jjbitVec63 = {
0898    0xffffffff03ff0000L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
0899 };
0900 static final long[] jjbitVec64 = {
0901    0x1fb0e7800000000L, 0x0L, 0xffff000000000000L, 0x301L
0902 };
0903 static final long[] jjbitVec65 = {
0904    0xe000000L, 0x0L, 0x0L, 0x0L
0905 };
0906 static final long[] jjbitVec66 = {
0907    0xc00000L, 0x0L, 0x0L, 0x0L
0908 };
0909 static final long[] jjbitVec67 = {
0910    0x8000000000000000L, 0x8000000000000001L, 0x0L, 0x21fff0000L
0911 };
0912 static final long[] jjbitVec68 = {
0913    0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
0914 };
0915 static final long[] jjbitVec69 = {
0916    0x9800000004L, 0x0L, 0x0L, 0x0L
0917 };
0918 static final long[] jjbitVec70 = {
0919    0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
0920 };
0921 static final long[] jjbitVec71 = {
0922    0x18000f00000000L, 0xffd700000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
0923 };
0924 static final long[] jjbitVec72 = {
0925    0x87fffffe03ff0000L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x1cfcfcfcL
0926 };
0927 static final long[] jjbitVec73 = {
0928    0xffffffffffffffffL, 0x700007fffL, 0x0L, 0x0L
0929 };
0930 static final long[] jjbitVec74 = {
0931    0x0L, 0x0L, 0x78L, 0x0L
0932 };
0933 static final long[] jjbitVec75 = {
0934    0x0L, 0x0L, 0xbbfffffbfffe0000L, 0x16L
0935 };
0936 static final long[] jjbitVec76 = {
0937    0x0L, 0x10000003ff800L, 0x0L, 0x3d9f9fc00000L
0938 };
0939 static final long[] jjbitVec77 = {
0940    0xffff000000020000L, 0x7ffL, 0x1ffc000000000L, 0x0L
0941 };
0942 static final long[] jjbitVec78 = {
0943    0xd00000000000000eL, 0xc001e3fffL, 0xf00000000000000eL, 0xc0080399fL
0944 };
0945 static final long[] jjbitVec79 = {
0946    0xd00000000000000cL, 0x3000000003987L, 0xd00000000000000eL, 0x3bbfL
0947 };
0948 static final long[] jjbitVec80 = {
0949    0xd00000000000000eL, 0xc0398fL, 0xc00000000000000cL, 0x803dc7L
0950 };
0951 static final long[] jjbitVec81 = {
0952    0xc00000000000000eL, 0x603ddfL, 0xc00000000000000cL, 0x603ddfL
0953 };
0954 static final long[] jjbitVec82 = {
0955    0xc00000000000000cL, 0x803dcfL, 0xcL, 0xc0000ff5f8400L
0956 };
0957 static final long[] jjbitVec83 = {
0958    0x7f2000000000000L, 0x7f80L, 0x1bf2000000000000L, 0x3f00L
0959 };
0960 static final long[] jjbitVec84 = {
0961    0xc2a0000003000000L, 0xfffe000000000000L, 0x1ffffffffeff00dfL, 0x40L
0962 };
0963 static final long[] jjbitVec85 = {
0964    0x3c7f00000000000L, 0x3c00000L, 0x0L, 0x0L
0965 };
0966 static final long[] jjbitVec86 = {
0967    0x0L, 0x0L, 0xfff0000000000000L, 0xfffffL
0968 };
0969 static final long[] jjbitVec87 = {
0970    0x0L, 0x0L, 0x20000000000L, 0x0L
0971 };
0972 static final long[] jjbitVec88 = {
0973    0x0L, 0x0L, 0x0L, 0x21fff0000L
0974 };
0975 static final long[] jjbitVec89 = {
0976    0xfc0000000000L, 0x0L, 0x6000000L, 0x0L
0977 };
0978 static final long[] jjbitVec90 = {
0979    0x40000000L, 0x0L, 0x0L, 0x0L
0980 };
0981 static final long[] jjbitVec91 = {
0982    0xf00000000L, 0x0L, 0x0L, 0x0L
0983 };
0984 static final long[] jjbitVec92 = {
0985    0xc000000000000008L, 0x1e01L, 0xc00000000000000cL, 0x801981L
0986 };
0987 static final long[] jjbitVec93 = {
0988    0xc000000000000008L, 0x1L, 0xc000000000000008L, 0x1a01L
0989 };
0990 static final long[] jjbitVec94 = {
0991    0x400000000000000cL, 0x801981L, 0xc000000000000000L, 0x801dc6L
0992 };
0993 static final long[] jjbitVec95 = {
0994    0xeL, 0x1eL, 0x400000000000000cL, 0x600d9fL
0995 };
0996 static final long[] jjbitVec96 = {
0997    0xc00000000000000cL, 0x801dc1L, 0xcL, 0xc0000ff038000L
0998 };
0999 static final long[] jjbitVec97 = {
1000    0xc000000000000000L, 0x8000000000000000L, 0x0L, 0x0L
1001 };
1002 static final long[] jjbitVec98 = {
1003    0x102100000000000L, 0xc00000L, 0x0L, 0x0L
1004 };
1005 static final long[] jjbitVec99 = {
1006    0x0L, 0x0L, 0xc040000000000000L, 0x1bfL
1007 };
1008 static final long[] jjbitVec100 = {
1009    0xd000000000000004L, 0x3000000003987L, 0xd00000000000000eL, 0x3bbfL
1010 };
1011 static final long[] jjbitVec101 = {
1012    0x1600L, 0x0L, 0x0L, 0x0L
1013 };
1014 static final long[] jjbitVec102 = {
1015    0x0L, 0xffc000000000L, 0x0L, 0xffc000000000L
1016 };
1017 static final long[] jjbitVec103 = {
1018    0x1000000L, 0x0L, 0x0L, 0x8000000000000000L
1019 };
1020 static final long[] jjbitVec104 = {
1021    0x3ff0000L, 0x0L, 0x0L, 0x0L
1022 };
1023 static final long[] jjbitVec105 = {
1024    0x0L, 0x3ff00000000L, 0x0L, 0x3ff000000000000L
1025 };
1026 static final long[] jjbitVec106 = {
1027    0x0L, 0xffc000000000L, 0x0L, 0xff8000000000L
1028 };
1029 static final long[] jjbitVec107 = {
1030    0x0L, 0xffc000000000L, 0x0L, 0x0L
1031 };
1032 static final long[] jjbitVec108 = {
1033    0x0L, 0x3ff0000L, 0x0L, 0x3ff0000L
1034 };
1035 static final long[] jjbitVec109 = {
1036    0x3ff00000000L, 0x0L, 0x0L, 0x0L
1037 };
1038 static final long[] jjbitVec110 = {
1039    0x0L, 0x3ffL, 0x0L, 0x0L
1040 };
1041 static final long[] jjbitVec111 = {
1042    0x0L, 0x3fe0000000000L, 0x0L, 0x0L
1043 };
1044 static final long[] jjbitVec112 = {
1045    0x0L, 0x0L, 0x0L, 0x3ff00000000L
1046 };
1047 static final long[] jjbitVec113 = {
1048    0x8000000000000000L, 0x1L, 0x0L, 0x0L
1049 };
1050 static final long[] jjbitVec114 = {
1051    0x0L, 0x0L, 0x0L, 0x800000000000000L
1052 };
1053 static final long[] jjbitVec115 = {
1054    0x18000000000000L, 0xe000L, 0x0L, 0x0L
1055 };
1056 static final long[] jjbitVec116 = {
1057    0x8000000000000000L, 0x2000000000L, 0x0L, 0x0L
1058 };
1059 private int jjMoveNfa_0(int startState, int curPos)
1060 {
1061    int startsAt = 0;
1062    jjnewStateCnt = 106;
1063    int i = 1;
1064    jjstateSet[0] = startState;
1065    int kind = 0x7fffffff;
1066    for (;;)
1067    {
1068       if (++jjround == 0x7fffffff)
1069          ReInitRounds();
1070       if (curChar < 64)
1071       {
1072          long l = 1L << curChar;
1073          do
1074          {
1075             switch(jjstateSet[--i])
1076             {
1077                case 0:
1078                   if ((0x3ff000000000000L & l) != 0L)
1079                   {
1080                      if (kind > 95)
1081                         kind = 95;
1082                      jjCheckNAdd(97);
1083                   }
1084                   else if (curChar == 47)
1085                      jjAddStates(0, 1);
1086                   else if (curChar == 36)
1087                   {
1088                      if (kind > 113)
1089                         kind = 113;
1090                      jjCheckNAddTwoStates(51, 52);
1091                   }
1092                   else if (curChar == 39)
1093                      jjCheckNAddStates(2, 4);
1094                   else if (curChar == 34)
1095                      jjCheckNAddStates(5, 7);
1096                   else if (curChar == 46)
1097                      jjCheckNAdd(13);
1098                   else if (curChar == 32)
1099                   {
1100                      if (kind > 4)
1101                         kind = 4;
1102                   }
1103                   else if (curChar == 12)
1104                   {
1105                      if (kind > 3)
1106                         kind = 3;
1107                   }
1108                   else if (curChar == 9)
1109                   {
1110                      if (kind > 1)
1111                         kind = 1;
1112                   }
1113                   if ((0x3ff000000000000L & l) != 0L)
1114                   {
1115                      if (kind > 125)
1116                         kind = 125;
1117                   }
1118                   if ((0x3ff000000000000L & l) != 0L)
1119                   {
1120                      if (kind > 122)
1121                         kind = 122;
1122                   }
1123                   if ((0x3fe000000000000L & l) != 0L)
1124                   {
1125                      if (kind > 93)
1126                         kind = 93;
1127                      jjCheckNAddStates(8, 12);
1128                   }
1129                   else if (curChar == 48)
1130                   {
1131                      if (kind > 93)
1132                         kind = 93;
1133                      jjCheckNAddStates(13, 15);
1134                   }
1135                   break;
1136                case 6:
1137                case 51:
1138                   if ((0x3ff001000000000L & l) == 0L)
1139                      break;
1140                   if (kind > 113)
1141                      kind = 113;
1142                   jjCheckNAddTwoStates(51, 52);
1143                   break;
1144                case 106:
1145                   if ((0x3ff001000000000L & l) == 0L)
1146                      break;
1147                   if (kind > 113)
1148                      kind = 113;
1149                   jjCheckNAddTwoStates(51, 52);
1150                   break;
1151                case 67:
1152                   if ((0xffff7bffffffdbffL & l) != 0L)
1153                      jjCheckNAddStates(16, 18);
1154                   break;
1155                case 107:
1156                   if ((0xffff7fffffffdbffL & l) != 0L)
1157                      jjCheckNAddStates(16, 18);
1158                   else if (curChar == 47)
1159                   {
1160                      if (kind > 126)
1161                         kind = 126;
1162                      jjCheckNAddTwoStates(72, 73);
1163                   }
1164                   break;
1165                case 54:
1166                   if ((0x3ff001000000000L & l) != 0L)
1167                   {
1168                      if (kind > 113)
1169                         kind = 113;
1170                      jjCheckNAddTwoStates(51, 52);
1171                   }
1172                   if ((0x3ff000000000000L & l) != 0L)
1173                      jjstateSet[jjnewStateCnt++] = 59;
1174                   if ((0x3ff000000000000L & l) != 0L)
1175                      jjstateSet[jjnewStateCnt++] = 55;
1176                   break;
1177                case 10:
1178                   if ((0x3ff001000000000L & l) == 0L)
1179                      break;
1180                   if (kind > 113)
1181                      kind = 113;
1182                   jjCheckNAddTwoStates(51, 52);
1183                   break;
1184                case 53:
1185                   if ((0x3ff001000000000L & l) != 0L)
1186                   {
1187                      if (kind > 113)
1188                         kind = 113;
1189                      jjCheckNAddTwoStates(51, 52);
1190                   }
1191                   if ((0x3ff000000000000L & l) != 0L)
1192                      jjstateSet[jjnewStateCnt++] = 58;
1193                   if ((0x3ff000000000000L & l) != 0L)
1194                      jjstateSet[jjnewStateCnt++] = 54;
1195                   break;
1196                case 5:
1197                   if ((0x3ff001000000000L & l) == 0L)
1198                      break;
1199                   if (kind > 113)
1200                      kind = 113;
1201                   jjCheckNAddTwoStates(51, 52);
1202                   break;
1203                case 1:
1204                   if (curChar == 12 && kind > 3)
1205                      kind = 3;
1206                   break;
1207                case 2:
1208                   if (curChar == 32 && kind > 4)
1209                      kind = 4;
1210                   break;
1211                case 12:
1212                   if (curChar == 46)
1213                      jjCheckNAdd(13);
1214                   break;
1215                case 13:
1216                   if ((0x3ff000000000000L & l) == 0L)
1217                      break;
1218                   if (kind > 93)
1219                      kind = 93;
1220                   jjCheckNAddTwoStates(13, 14);
1221                   break;
1222                case 15:
1223                   if ((0x280000000000L & l) != 0L)
1224                      jjCheckNAdd(16);
1225                   break;
1226                case 16:
1227                   if ((0x3ff000000000000L & l) == 0L)
1228                      break;
1229                   if (kind > 93)
1230                      kind = 93;
1231                   jjCheckNAdd(16);
1232                   break;
1233                case 17:
1234                   if (curChar == 34)
1235                      jjCheckNAddStates(5, 7);
1236                   break;
1237                case 18:
1238                   if ((0xfffffffbffffdbffL & l) != 0L)
1239                      jjCheckNAddStates(5, 7);
1240                   break;
1241                case 19:
1242                   if (curChar == 34 && kind > 102)
1243                      kind = 102;
1244                   break;
1245                case 21:
1246                   jjCheckNAddStates(5, 7);
1247                   break;
1248                case 23:
1249                case 28:
1250                   if ((0x3ff000000000000L & l) != 0L)
1251                      jjCheckNAdd(24);
1252                   break;
1253                case 24:
1254                   if ((0x3ff000000000000L & l) != 0L)
1255                      jjCheckNAddStates(5, 7);
1256                   break;
1257                case 26:
1258                   if ((0x3ff000000000000L & l) != 0L)
1259                      jjstateSet[jjnewStateCnt++] = 27;
1260                   break;
1261                case 27:
1262                   if ((0x3ff000000000000L & l) != 0L)
1263                      jjstateSet[jjnewStateCnt++] = 28;
1264                   break;
1265                case 29:
1266                   if ((0x2400L & l) != 0L)
1267                      jjCheckNAddStates(5, 7);
1268                   break;
1269                case 30:
1270                   if (curChar == 10)
1271                      jjCheckNAddStates(5, 7);
1272                   break;
1273                case 31:
1274                   if (curChar == 13)
1275                      jjstateSet[jjnewStateCnt++] = 30;
1276                   break;
1277                case 32:
1278                   if (curChar == 39)
1279                      jjCheckNAddStates(2, 4);
1280                   break;
1281                case 33:
1282                   if ((0xffffff7fffffdbffL & l) != 0L)
1283                      jjCheckNAddStates(2, 4);
1284                   break;
1285                case 34:
1286                   if (curChar == 39 && kind > 102)
1287                      kind = 102;
1288                   break;
1289                case 36:
1290                   jjCheckNAddStates(2, 4);
1291                   break;
1292                case 38:
1293                case 43:
1294                   if ((0x3ff000000000000L & l) != 0L)
1295                      jjCheckNAdd(39);
1296                   break;
1297                case 39:
1298                   if ((0x3ff000000000000L & l) != 0L)
1299                      jjCheckNAddStates(2, 4);
1300                   break;
1301                case 41:
1302                   if ((0x3ff000000000000L & l) != 0L)
1303                      jjstateSet[jjnewStateCnt++] = 42;
1304                   break;
1305                case 42:
1306                   if ((0x3ff000000000000L & l) != 0L)
1307                      jjstateSet[jjnewStateCnt++] = 43;
1308                   break;
1309                case 44:
1310                   if ((0x2400L & l) != 0L)
1311                      jjCheckNAddStates(2, 4);
1312                   break;
1313                case 45:
1314                   if (curChar == 10)
1315                      jjCheckNAddStates(2, 4);
1316                   break;
1317                case 46:
1318                   if (curChar == 13)
1319                      jjstateSet[jjnewStateCnt++] = 45;
1320                   break;
1321                case 48:
1322                   if ((0x3ff000000000000L & l) != 0L)
1323                      jjstateSet[jjnewStateCnt++] = 49;
1324                   break;
1325                case 49:
1326                   if ((0x3ff000000000000L & l) != 0L && kind > 112)
1327                      kind = 112;
1328                   break;
1329                case 50:
1330                   if (curChar != 36)
1331                      break;
1332                   if (kind > 113)
1333                      kind = 113;
1334                   jjCheckNAddTwoStates(51, 52);
1335                   break;
1336                case 55:
1337                case 59:
1338                case 101:
1339                   if ((0x3ff000000000000L & l) != 0L)
1340                      jjCheckNAdd(56);
1341                   break;
1342                case 56:
1343                   if ((0x3ff000000000000L & l) == 0L)
1344                      break;
1345                   if (kind > 113)
1346                      kind = 113;
1347                   jjCheckNAddTwoStates(51, 52);
1348                   break;
1349                case 57:
1350                   if ((0x3ff000000000000L & l) != 0L)
1351                      jjstateSet[jjnewStateCnt++] = 58;
1352                   break;
1353                case 58:
1354                   if ((0x3ff000000000000L & l) != 0L)
1355                      jjstateSet[jjnewStateCnt++] = 59;
1356                   break;
1357                case 63:
1358                   if ((0x3ff000000000000L & l) != 0L && kind > 122)
1359                      kind = 122;
1360                   break;
1361                case 65:
1362                   if ((0x3ff000000000000L & l) != 0L && kind > 125)
1363                      kind = 125;
1364                   break;
1365                case 66:
1366                   if (curChar == 47)
1367                      jjAddStates(0, 1);
1368                   break;
1369                case 68:
1370                   if ((0xffff7fffffffdbffL & l) != 0L)
1371                      jjCheckNAddStates(16, 18);
1372                   break;
1373                case 70:
1374                   if ((0xffffffffffffdbffL & l) != 0L)
1375                      jjCheckNAddStates(16, 18);
1376                   break;
1377                case 71:
1378                   if (curChar != 47)
1379                      break;
1380                   if (kind > 126)
1381                      kind = 126;
1382                   jjCheckNAddTwoStates(72, 73);
1383                   break;
1384                case 72:
1385                   if ((0x3ff001000000000L & l) == 0L)
1386                      break;
1387                   if (kind > 126)
1388                      kind = 126;
1389                   jjCheckNAddTwoStates(72, 73);
1390                   break;
1391                case 74:
1392                   if ((0x3ff000000000000L & l) != 0L)
1393                      jjstateSet[jjnewStateCnt++] = 75;
1394                   break;
1395                case 75:
1396                   if ((0x3ff000000000000L & l) != 0L)
1397                      jjstateSet[jjnewStateCnt++] = 76;
1398                   break;
1399                case 76:
1400                case 80:
1401                   if ((0x3ff000000000000L & l) != 0L)
1402                      jjCheckNAdd(77);
1403                   break;
1404                case 77:
1405                   if ((0x3ff000000000000L & l) == 0L)
1406                      break;
1407                   if (kind > 126)
1408                      kind = 126;
1409                   jjCheckNAddTwoStates(72, 73);
1410                   break;
1411                case 78:
1412                   if ((0x3ff000000000000L & l) != 0L)
1413                      jjstateSet[jjnewStateCnt++] = 79;
1414                   break;
1415                case 79:
1416                   if ((0x3ff000000000000L & l) != 0L)
1417                      jjstateSet[jjnewStateCnt++] = 80;
1418                   break;
1419                case 82:
1420                   if (curChar != 48)
1421                      break;
1422                   if (kind > 93)
1423                      kind = 93;
1424                   jjCheckNAddStates(13, 15);
1425                   break;
1426                case 83:
1427                   if (curChar != 46)
1428                      break;
1429                   if (kind > 93)
1430                      kind = 93;
1431                   jjCheckNAddTwoStates(84, 85);
1432                   break;
1433                case 84:
1434                   if ((0x3ff000000000000L & l) == 0L)
1435                      break;
1436                   if (kind > 93)
1437                      kind = 93;
1438                   jjCheckNAddTwoStates(84, 85);
1439                   break;
1440                case 86:
1441                   if ((0x280000000000L & l) != 0L)
1442                      jjCheckNAdd(87);
1443                   break;
1444                case 87:
1445                   if ((0x3ff000000000000L & l) == 0L)
1446                      break;
1447                   if (kind > 93)
1448                      kind = 93;
1449                   jjCheckNAdd(87);
1450                   break;
1451                case 89:
1452                   if ((0x280000000000L & l) != 0L)
1453                      jjCheckNAdd(90);
1454                   break;
1455                case 90:
1456                   if ((0x3ff000000000000L & l) == 0L)
1457                      break;
1458                   if (kind > 93)
1459                      kind = 93;
1460                   jjCheckNAdd(90);
1461                   break;
1462                case 92:
1463                   if ((0x3ff000000000000L & l) == 0L)
1464                      break;
1465                   if (kind > 101)
1466                      kind = 101;
1467                   jjstateSet[jjnewStateCnt++] = 92;
1468                   break;
1469                case 93:
1470                   if ((0x3fe000000000000L & l) == 0L)
1471                      break;
1472                   if (kind > 93)
1473                      kind = 93;
1474                   jjCheckNAddStates(8, 12);
1475                   break;
1476                case 94:
1477                   if ((0x3ff000000000000L & l) != 0L)
1478                      jjCheckNAddTwoStates(94, 83);
1479                   break;
1480                case 95:
1481                   if ((0x3ff000000000000L & l) == 0L)
1482                      break;
1483                   if (kind > 93)
1484                      kind = 93;
1485                   jjCheckNAddTwoStates(95, 88);
1486                   break;
1487                case 96:
1488                   if ((0x3ff000000000000L & l) == 0L)
1489                      break;
1490                   if (kind > 94)
1491                      kind = 94;
1492                   jjCheckNAdd(96);
1493                   break;
1494                case 97:
1495                   if ((0x3ff000000000000L & l) == 0L)
1496                      break;
1497                   if (kind > 95)
1498                      kind = 95;
1499                   jjCheckNAdd(97);
1500                   break;
1501                case 99:
1502                   if ((0x3ff000000000000L & l) != 0L)
1503                      jjstateSet[jjnewStateCnt++] = 100;
1504                   break;
1505                case 100:
1506                   if ((0x3ff000000000000L & l) != 0L)
1507                      jjstateSet[jjnewStateCnt++] = 101;
1508                   break;
1509                case 102:
1510                   if ((0x3ff000000000000L & l) != 0L)
1511                      jjstateSet[jjnewStateCnt++] = 103;
1512                   break;
1513                case 103:
1514                   if ((0x3ff000000000000L & l) != 0L)
1515                      jjstateSet[jjnewStateCnt++] = 104;
1516                   break;
1517                case 104:
1518                   if ((0x3ff000000000000L & l) != 0L)
1519                      jjstateSet[jjnewStateCnt++] = 105;
1520                   break;
1521                case 105:
1522                   if ((0x3ff000000000000L & l) != 0L && kind > 124)
1523                      kind = 124;
1524                   break;
1525                default : break;
1526             }
1527          } while(i != startsAt);
1528       }
1529       else if (curChar < 128)
1530       {
1531          long l = 1L << (curChar & 077);
1532          do
1533          {
1534             switch(jjstateSet[--i])
1535             {
1536                case 0:
1537                   if ((0x7fffffe87fffffeL & l) != 0L)
1538                   {
1539                      if (kind > 113)
1540                         kind = 113;
1541                      jjCheckNAddTwoStates(51, 52);
1542                   }
1543                   if ((0x7e0000007eL & l) != 0L)
1544                   {
1545                      if (kind > 125)
1546                         kind = 125;
1547                   }
1548                   else if (curChar == 117)
1549                      jjAddStates(19, 20);
1550                   else if (curChar == 95)
1551                   {
1552                      if (kind > 123)
1553                         kind = 123;
1554                   }
1555                   else if (curChar == 120)
1556                      jjstateSet[jjnewStateCnt++] = 48;
1557                   else if (curChar == 116)
1558                      jjstateSet[jjnewStateCnt++] = 6;
1559                   if (curChar == 102)
1560                      jjstateSet[jjnewStateCnt++] = 10;
1561                   break;
1562                case 6:
1563                   if ((0x7fffffe87fffffeL & l) != 0L)
1564                   {
1565                      if (kind > 113)
1566                         kind = 113;
1567                      jjCheckNAddTwoStates(51, 52);
1568                   }
1569                   if (curChar == 117)
1570                      jjAddStates(21, 22);
1571                   else if (curChar == 114)
1572                      jjstateSet[jjnewStateCnt++] = 5;
1573                   break;
1574                case 106:
1575                   if ((0x7fffffe87fffffeL & l) != 0L)
1576                   {
1577                      if (kind > 113)
1578                         kind = 113;
1579                      jjCheckNAddTwoStates(51, 52);
1580                   }
1581                   if (curChar == 117)
1582                      jjAddStates(21, 22);
1583                   break;
1584                case 67:
1585                   if ((0xffffffffefffffffL & l) != 0L)
1586                      jjCheckNAddStates(16, 18);
1587                   else if (curChar == 92)
1588                      jjCheckNAdd(70);
1589                   break;
1590                case 107:
1591                   if ((0xffffffffefffffffL & l) != 0L)
1592                      jjCheckNAddStates(16, 18);
1593                   else if (curChar == 92)
1594                      jjCheckNAdd(70);
1595                   break;
1596                case 54:
1597                   if ((0x7fffffe87fffffeL & l) != 0L)
1598                   {
1599                      if (kind > 113)
1600                         kind = 113;
1601                      jjCheckNAddTwoStates(51, 52);
1602                   }
1603                   if ((0x7e0000007eL & l) != 0L)
1604                      jjstateSet[jjnewStateCnt++] = 59;
1605                   else if (curChar == 117)
1606                      jjAddStates(21, 22);
1607                   if ((0x7e0000007eL & l) != 0L)
1608                      jjstateSet[jjnewStateCnt++] = 55;
1609                   break;
1610                case 10:
1611                   if ((0x7fffffe87fffffeL & l) != 0L)
1612                   {
1613                      if (kind > 113)
1614                         kind = 113;
1615                      jjCheckNAddTwoStates(51, 52);
1616                   }
1617                   if (curChar == 117)
1618                      jjAddStates(21, 22);
1619                   else if (curChar == 97)
1620                      jjstateSet[jjnewStateCnt++] = 9;
1621                   break;
1622                case 53:
1623                   if ((0x7fffffe87fffffeL & l) != 0L)
1624                   {
1625                      if (kind > 113)
1626                         kind = 113;
1627                      jjCheckNAddTwoStates(51, 52);
1628                   }
1629                   if ((0x7e0000007eL & l) != 0L)
1630                      jjstateSet[jjnewStateCnt++] = 58;
1631                   else if (curChar == 117)
1632                      jjAddStates(21, 22);
1633                   if ((0x7e0000007eL & l) != 0L)
1634                      jjstateSet[jjnewStateCnt++] = 54;
1635                   break;
1636                case 5:
1637                   if ((0x7fffffe87fffffeL & l) != 0L)
1638                   {
1639                      if (kind > 113)
1640                         kind = 113;
1641                      jjCheckNAddTwoStates(51, 52);
1642                   }
1643                   if (curChar == 117)
1644                      jjAddStates(21, 22);
1645                   if (curChar == 117)
1646                      jjCheckNAdd(4);
1647                   break;
1648                case 4:
1649                   if (curChar == 101 && kind > 92)
1650                      kind = 92;
1651                   break;
1652                case 7:
1653                   if (curChar == 116)
1654                      jjstateSet[jjnewStateCnt++] = 6;
1655                   break;
1656                case 8:
1657                   if (curChar == 115)
1658                      jjCheckNAdd(4);
1659                   break;
1660                case 9:
1661                   if (curChar == 108)
1662                      jjstateSet[jjnewStateCnt++] = 8;
1663                   break;
1664                case 11:
1665                   if (curChar == 102)
1666                      jjstateSet[jjnewStateCnt++] = 10;
1667                   break;
1668                case 14:
1669                   if ((0x2000000020L & l) != 0L)
1670                      jjAddStates(23, 24);
1671                   break;
1672                case 18:
1673                   if ((0xffffffffefffffffL & l) != 0L)
1674                      jjCheckNAddStates(5, 7);
1675                   break;
1676                case 20:
1677                   if (curChar == 92)
1678                      jjAddStates(25, 29);
1679                   break;
1680                case 21:
1681                   jjCheckNAddStates(5, 7);
1682                   break;
1683                case 22:
1684                   if (curChar == 120)
1685                      jjstateSet[jjnewStateCnt++] = 23;
1686                   break;
1687                case 23:
1688                case 28:
1689                   if ((0x7e0000007eL & l) != 0L)
1690                      jjCheckNAdd(24);
1691                   break;
1692                case 24:
1693                   if ((0x7e0000007eL & l) != 0L)
1694                      jjCheckNAddStates(5, 7);
1695                   break;
1696                case 25:
1697                   if (curChar == 117)
1698                      jjstateSet[jjnewStateCnt++] = 26;
1699                   break;
1700                case 26:
1701                   if ((0x7e0000007eL & l) != 0L)
1702                      jjstateSet[jjnewStateCnt++] = 27;
1703                   break;
1704                case 27:
1705                   if ((0x7e0000007eL & l) != 0L)
1706                      jjstateSet[jjnewStateCnt++] = 28;
1707                   break;
1708                case 33:
1709                   if ((0xffffffffefffffffL & l) != 0L)
1710                      jjCheckNAddStates(2, 4);
1711                   break;
1712                case 35:
1713                   if (curChar == 92)
1714                      jjAddStates(30, 34);
1715                   break;
1716                case 36:
1717                   jjCheckNAddStates(2, 4);
1718                   break;
1719                case 37:
1720                   if (curChar == 120)
1721                      jjstateSet[jjnewStateCnt++] = 38;
1722                   break;
1723                case 38:
1724                case 43:
1725                   if ((0x7e0000007eL & l) != 0L)
1726                      jjCheckNAdd(39);
1727                   break;
1728                case 39:
1729                   if ((0x7e0000007eL & l) != 0L)
1730                      jjCheckNAddStates(2, 4);
1731                   break;
1732                case 40:
1733                   if (curChar == 117)
1734                      jjstateSet[jjnewStateCnt++] = 41;
1735                   break;
1736                case 41:
1737                   if ((0x7e0000007eL & l) != 0L)
1738                      jjstateSet[jjnewStateCnt++] = 42;
1739                   break;
1740                case 42:
1741                   if ((0x7e0000007eL & l) != 0L)
1742                      jjstateSet[jjnewStateCnt++] = 43;
1743                   break;
1744                case 47:
1745                   if (curChar == 120)
1746                      jjstateSet[jjnewStateCnt++] = 48;
1747                   break;
1748                case 48:
1749                   if ((0x7e0000007eL & l) != 0L)
1750                      jjstateSet[jjnewStateCnt++] = 49;
1751                   break;
1752                case 49:
1753                   if ((0x7e0000007eL & l) != 0L && kind > 112)
1754                      kind = 112;
1755                   break;
1756                case 50:
1757                   if ((0x7fffffe87fffffeL & l) == 0L)
1758                      break;
1759                   if (kind > 113)
1760                      kind = 113;
1761                   jjCheckNAddTwoStates(51, 52);
1762                   break;
1763                case 51:
1764                   if ((0x7fffffe87fffffeL & l) == 0L)
1765                      break;
1766                   if (kind > 113)
1767                      kind = 113;
1768                   jjCheckNAddTwoStates(51, 52);
1769                   break;
1770                case 52:
1771                   if (curChar == 117)
1772                      jjAddStates(21, 22);
1773                   break;
1774                case 55:
1775                case 59:
1776                case 101:
1777                   if ((0x7e0000007eL & l) != 0L)
1778                      jjCheckNAdd(56);
1779                   break;
1780                case 56:
1781                   if ((0x7e0000007eL & l) == 0L)
1782                      break;
1783                   if (kind > 113)
1784                      kind = 113;
1785                   jjCheckNAddTwoStates(51, 52);
1786                   break;
1787                case 57:
1788                   if ((0x7e0000007eL & l) != 0L)
1789                      jjstateSet[jjnewStateCnt++] = 58;
1790                   break;
1791                case 58:
1792                   if ((0x7e0000007eL & l) != 0L)
1793                      jjstateSet[jjnewStateCnt++] = 59;
1794                   break;
1795                case 64:
1796                   if (curChar == 95 && kind > 123)
1797                      kind = 123;
1798                   break;
1799                case 65:
1800                   if ((0x7e0000007eL & l) != 0L && kind > 125)
1801                      kind = 125;
1802                   break;
1803                case 68:
1804                   if ((0xffffffffefffffffL & l) != 0L)
1805                      jjCheckNAddStates(16, 18);
1806                   break;
1807                case 69:
1808                   if (curChar == 92)
1809                      jjCheckNAdd(70);
1810                   break;
1811                case 70:
1812                   jjCheckNAddStates(16, 18);
1813                   break;
1814                case 72:
1815                   if ((0x7fffffe87fffffeL & l) == 0L)
1816                      break;
1817                   if (kind > 126)
1818                      kind = 126;
1819                   jjCheckNAddTwoStates(72, 73);
1820                   break;
1821                case 73:
1822                   if (curChar == 117)
1823                      jjAddStates(35, 36);
1824                   break;
1825                case 74:
1826                   if ((0x7e0000007eL & l) != 0L)
1827                      jjstateSet[jjnewStateCnt++] = 75;
1828                   break;
1829                case 75:
1830                   if ((0x7e0000007eL & l) != 0L)
1831                      jjstateSet[jjnewStateCnt++] = 76;
1832                   break;
1833                case 76:
1834                case 80:
1835                   if ((0x7e0000007eL & l) != 0L)
1836                      jjCheckNAdd(77);
1837                   break;
1838                case 77:
1839                   if ((0x7e0000007eL & l) == 0L)
1840                      break;
1841                   if (kind > 126)
1842                      kind = 126;
1843                   jjCheckNAddTwoStates(72, 73);
1844                   break;
1845                case 78:
1846                   if ((0x7e0000007eL & l) != 0L)
1847                      jjstateSet[jjnewStateCnt++] = 79;
1848                   break;
1849                case 79:
1850                   if ((0x7e0000007eL & l) != 0L)
1851                      jjstateSet[jjnewStateCnt++] = 80;
1852                   break;
1853                case 81:
1854                   if (curChar == 92)
1855                      jjCheckNAdd(70);
1856                   break;
1857                case 85:
1858                   if ((0x2000000020L & l) != 0L)
1859                      jjAddStates(37, 38);
1860                   break;
1861                case 88:
1862                   if ((0x2000000020L & l) != 0L)
1863                      jjAddStates(39, 40);
1864                   break;
1865                case 91:
1866                   if ((0x100000001000000L & l) != 0L)
1867                      jjCheckNAdd(92);
1868                   break;
1869                case 92:
1870                   if ((0x7e0000007eL & l) == 0L)
1871                      break;
1872                   if (kind > 101)
1873                      kind = 101;
1874                   jjCheckNAdd(92);
1875                   break;
1876                case 98:
1877                   if (curChar == 117)
1878                      jjAddStates(19, 20);
1879                   break;
1880                case 99:
1881                   if ((0x7e0000007eL & l) != 0L)
1882                      jjstateSet[jjnewStateCnt++] = 100;
1883                   break;
1884                case 100:
1885                   if ((0x7e0000007eL & l) != 0L)
1886                      jjstateSet[jjnewStateCnt++] = 101;
1887                   break;
1888                case 102:
1889                   if ((0x7e0000007eL & l) != 0L)
1890                      jjstateSet[jjnewStateCnt++] = 103;
1891                   break;
1892                case 103:
1893                   if ((0x7e0000007eL & l) != 0L)
1894                      jjstateSet[jjnewStateCnt++] = 104;
1895                   break;
1896                case 104:
1897                   if ((0x7e0000007eL & l) != 0L)
1898                      jjstateSet[jjnewStateCnt++] = 105;
1899                   break;
1900                case 105:
1901                   if ((0x7e0000007eL & l) != 0L && kind > 124)
1902                      kind = 124;
1903                   break;
1904                default : break;
1905             }
1906          } while(i != startsAt);
1907       }
1908       else
1909       {
1910          int hiByte = (int)(curChar >> 8);
1911          int i1 = hiByte >> 6;
1912          long l1 = 1L << (hiByte & 077);
1913          int i2 = (curChar & 0xff) >> 6;
1914          long l2 = 1L << (curChar & 077);
1915          do
1916          {
1917             switch(jjstateSet[--i])
1918             {
1919                case 0:
1920                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1921                   {
1922                      if (kind > 7)
1923                         kind = 7;
1924                   }
1925                   if (jjCanMove_4(hiByte, i1, i2, l1, l2))
1926                   {
1927                      if (kind > 113)
1928                         kind = 113;
1929                      jjCheckNAddTwoStates(51, 52);
1930                   }
1931                   if (jjCanMove_6(hiByte, i1, i2, l1, l2))
1932                   {
1933                      if (kind > 119)
1934                         kind = 119;
1935                   }
1936                   if (jjCanMove_7(hiByte, i1, i2, l1, l2))
1937                   {
1938                      if (kind > 120)
1939                         kind = 120;
1940                   }
1941                   if (jjCanMove_8(hiByte, i1, i2, l1, l2))
1942                   {
1943                      if (kind > 121)
1944                         kind = 121;
1945                   }
1946                   if (jjCanMove_9(hiByte, i1, i2, l1, l2))
1947                   {
1948                      if (kind > 122)
1949                         kind = 122;
1950                   }
1951                   if (jjCanMove_10(hiByte, i1, i2, l1, l2))
1952                   {
1953                      if (kind > 123)
1954                         kind = 123;
1955                   }
1956                   break;
1957                case 6:
1958                case 51:
1959                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
1960                      break;
1961                   if (kind > 113)
1962                      kind = 113;
1963                   jjCheckNAddTwoStates(51, 52);
1964                   break;
1965                case 106:
1966                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
1967                      break;
1968                   if (kind > 113)
1969                      kind = 113;
1970                   jjCheckNAddTwoStates(51, 52);
1971                   break;
1972                case 67:
1973                case 70:
1974                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1975                      jjCheckNAddStates(16, 18);
1976                   break;
1977                case 107:
1978                case 68:
1979                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1980                      jjCheckNAddStates(16, 18);
1981                   break;
1982                case 54:
1983                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
1984                      break;
1985                   if (kind > 113)
1986                      kind = 113;
1987                   jjCheckNAddTwoStates(51, 52);
1988                   break;
1989                case 10:
1990                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
1991                      break;
1992                   if (kind > 113)
1993                      kind = 113;
1994                   jjCheckNAddTwoStates(51, 52);
1995                   break;
1996                case 53:
1997                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
1998                      break;
1999                   if (kind > 113)
2000                      kind = 113;
2001                   jjCheckNAddTwoStates(51, 52);
2002                   break;
2003                case 5:
2004                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
2005                      break;
2006                   if (kind > 113)
2007                      kind = 113;
2008                   jjCheckNAddTwoStates(51, 52);
2009                   break;
2010                case 3:
2011                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
2012                      kind = 7;
2013                   break;
2014                case 18:
2015                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2016                      jjCheckNAddStates(5, 7);
2017                   break;
2018                case 21:
2019                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2020                      jjCheckNAddStates(5, 7);
2021                   break;
2022                case 29:
2023                   if (jjCanMove_3(hiByte, i1, i2, l1, l2))
2024                      jjCheckNAddStates(5, 7);
2025                   break;
2026                case 33:
2027                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2028                      jjCheckNAddStates(2, 4);
2029                   break;
2030                case 36:
2031                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
2032                      jjCheckNAddStates(2, 4);
2033                   break;
2034                case 44:
2035                   if (jjCanMove_3(hiByte, i1, i2, l1, l2))
2036                      jjCheckNAddStates(2, 4);
2037                   break;
2038                case 50:
2039                   if (!jjCanMove_4(hiByte, i1, i2, l1, l2))
2040                      break;
2041                   if (kind > 113)
2042                      kind = 113;
2043                   jjCheckNAddTwoStates(51, 52);
2044                   break;
2045                case 60:
2046                   if (jjCanMove_6(hiByte, i1, i2, l1, l2) && kind > 119)
2047                      kind = 119;
2048                   break;
2049                case 61:
2050                   if (jjCanMove_7(hiByte, i1, i2, l1, l2) && kind > 120)
2051                      kind = 120;
2052                   break;
2053                case 62:
2054                   if (jjCanMove_8(hiByte, i1, i2, l1, l2) && kind > 121)
2055                      kind = 121;
2056                   break;
2057                case 63:
2058                   if (jjCanMove_9(hiByte, i1, i2, l1, l2) && kind > 122)
2059                      kind = 122;
2060                   break;
2061                case 64:
2062                   if (jjCanMove_10(hiByte, i1, i2, l1, l2) && kind > 123)
2063                      kind = 123;
2064                   break;
2065                case 72:
2066                   if (!jjCanMove_5(hiByte, i1, i2, l1, l2))
2067                      break;
2068                   if (kind > 126)
2069                      kind = 126;
2070                   jjAddStates(41, 42);
2071                   break;
2072                default : break;
2073             }
2074          } while(i != startsAt);
2075       }
2076       if (kind != 0x7fffffff)
2077       {
2078          jjmatchedKind = kind;
2079          jjmatchedPos = curPos;
2080          kind = 0x7fffffff;
2081       }
2082       ++curPos;
2083       if ((i = jjnewStateCnt) == (startsAt = 106 - (jjnewStateCnt = startsAt)))
2084          return curPos;
2085       try { curChar = input_stream.readChar(); }
2086       catch(java.io.IOException e) { return curPos; }
2087    }
2088 }
2089 private int jjMoveStringLiteralDfa0_2()
2090 {
2091    switch(curChar)
2092    {
2093       case 42:
2094          return jjMoveStringLiteralDfa1_2(0x8000L);
2095       default :
2096          return 1;
2097    }
2098 }
2099 private int jjMoveStringLiteralDfa1_2(long active0)
2100 {
2101    try { curChar = input_stream.readChar(); }
2102    catch(java.io.IOException e) {
2103       return 1;
2104    }
2105    switch(curChar)
2106    {
2107       case 47:
2108          if ((active0 & 0x8000L) != 0L)
2109             return jjStopAtPos(1, 15);
2110          break;
2111       default :
2112          return 2;
2113    }
2114    return 2;
2115 }
2116 private int jjMoveStringLiteralDfa0_1()
2117 {
2118    return jjMoveNfa_1(4, 0);
2119 }
2120 private int jjMoveNfa_1(int startState, int curPos)
2121 {
2122    int startsAt = 0;
2123    jjnewStateCnt = 4;
2124    int i = 1;
2125    jjstateSet[0] = startState;
2126    int kind = 0x7fffffff;
2127    for (;;)
2128    {
2129       if (++jjround == 0x7fffffff)
2130          ReInitRounds();
2131       if (curChar < 64)
2132       {
2133          long l = 1L << curChar;
2134          do
2135          {
2136             switch(jjstateSet[--i])
2137             {
2138                case 4:
2139                   if ((0xffffffffffffdbffL & l) != 0L)
2140                   {
2141                      if (kind > 14)
2142                         kind = 14;
2143                      jjCheckNAddStates(43, 45);
2144                   }
2145                   else if ((0x2400L & l) != 0L)
2146                   {
2147                      if (kind > 14)
2148                         kind = 14;
2149                   }
2150                   if (curChar == 13)
2151                      jjstateSet[jjnewStateCnt++] = 2;
2152                   break;
2153                case 0:
2154                   if ((0xffffffffffffdbffL & l) == 0L)
2155                      break;
2156                   kind = 14;
2157                   jjCheckNAddStates(43, 45);
2158                   break;
2159                case 1:
2160                   if ((0x2400L & l) != 0L && kind > 14)
2161                      kind = 14;
2162                   break;
2163                case 2:
2164                   if (curChar == 10 && kind > 14)
2165                      kind = 14;
2166                   break;
2167                case 3:
2168                   if (curChar == 13)
2169                      jjstateSet[jjnewStateCnt++] = 2;
2170                   break;
2171                default : break;
2172             }
2173          } while(i != startsAt);
2174       }
2175       else if (curChar < 128)
2176       {
2177          long l = 1L << (curChar & 077);
2178          do
2179          {
2180             switch(jjstateSet[--i])
2181             {
2182                case 4:
2183                case 0:
2184                   kind = 14;
2185                   jjCheckNAddStates(43, 45);
2186                   break;
2187                default : break;
2188             }
2189          } while(i != startsAt);
2190       }
2191       else
2192       {
2193          int hiByte = (int)(curChar >> 8);
2194          int i1 = hiByte >> 6;
2195          long l1 = 1L << (hiByte & 077);
2196          int i2 = (curChar & 0xff) >> 6;
2197          long l2 = 1L << (curChar & 077);
2198          do
2199          {
2200             switch(jjstateSet[--i])
2201             {
2202                case 4:
2203                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2204                   {
2205                      if (kind > 14)
2206                         kind = 14;
2207                      jjCheckNAddStates(43, 45);
2208                   }
2209                   if (jjCanMove_3(hiByte, i1, i2, l1, l2))
2210                   {
2211                      if (kind > 14)
2212                         kind = 14;
2213                   }
2214                   break;
2215                case 0:
2216                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
2217                      break;
2218                   if (kind > 14)
2219                      kind = 14;
2220                   jjCheckNAddStates(43, 45);
2221                   break;
2222                case 1:
2223                   if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 14)
2224                      kind = 14;
2225                   break;
2226                default : break;
2227             }
2228          } while(i != startsAt);
2229       }
2230       if (kind != 0x7fffffff)
2231       {
2232          jjmatchedKind = kind;
2233          jjmatchedPos = curPos;
2234          kind = 0x7fffffff;
2235       }
2236       ++curPos;
2237       if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2238          return curPos;
2239       try { curChar = input_stream.readChar(); }
2240       catch(java.io.IOException e) { return curPos; }
2241    }
2242 }
2243 private int jjMoveStringLiteralDfa0_3()
2244 {
2245    return jjMoveNfa_3(4, 0);
2246 }
2247 private int jjMoveNfa_3(int startState, int curPos)
2248 {
2249    int startsAt = 0;
2250    jjnewStateCnt = 4;
2251    int i = 1;
2252    jjstateSet[0] = startState;
2253    int kind = 0x7fffffff;
2254    for (;;)
2255    {
2256       if (++jjround == 0x7fffffff)
2257          ReInitRounds();
2258       if (curChar < 64)
2259       {
2260          long l = 1L << curChar;
2261          do
2262          {
2263             switch(jjstateSet[--i])
2264             {
2265                case 4:
2266                   if ((0xf7fffff7ffffdbffL & l) != 0L)
2267                   {
2268                      if (kind > 129)
2269                         kind = 129;
2270                      jjCheckNAddStates(43, 45);
2271                   }
2272                   else if ((0x800000000002400L & l) != 0L)
2273                   {
2274                      if (kind > 129)
2275                         kind = 129;
2276                   }
2277                   if (curChar == 13)
2278                      jjstateSet[jjnewStateCnt++] = 2;
2279                   break;
2280                case 0:
2281                   if ((0xf7fffff7ffffdbffL & l) == 0L)
2282                      break;
2283                   kind = 129;
2284                   jjCheckNAddStates(43, 45);
2285                   break;
2286                case 1:
2287                   if ((0x800000000002400L & l) != 0L && kind > 129)
2288                      kind = 129;
2289                   break;
2290                case 2:
2291                   if (curChar == 10 && kind > 129)
2292                      kind = 129;
2293                   break;
2294                case 3:
2295                   if (curChar == 13)
2296                      jjstateSet[jjnewStateCnt++] = 2;
2297                   break;
2298                default : break;
2299             }
2300          } while(i != startsAt);
2301       }
2302       else if (curChar < 128)
2303       {
2304          long l = 1L << (curChar & 077);
2305          do
2306          {
2307             switch(jjstateSet[--i])
2308             {
2309                case 4:
2310                case 0:
2311                   kind = 129;
2312                   jjCheckNAddStates(43, 45);
2313                   break;
2314                default : break;
2315             }
2316          } while(i != startsAt);
2317       }
2318       else
2319       {
2320          int hiByte = (int)(curChar >> 8);
2321          int i1 = hiByte >> 6;
2322          long l1 = 1L << (hiByte & 077);
2323          int i2 = (curChar & 0xff) >> 6;
2324          long l2 = 1L << (curChar & 077);
2325          do
2326          {
2327             switch(jjstateSet[--i])
2328             {
2329                case 4:
2330                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
2331                   {
2332                      if (kind > 129)
2333                         kind = 129;
2334                      jjCheckNAddStates(43, 45);
2335                   }
2336                   if (jjCanMove_3(hiByte, i1, i2, l1, l2))
2337                   {
2338                      if (kind > 129)
2339                         kind = 129;
2340                   }
2341                   break;
2342                case 0:
2343                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
2344                      break;
2345                   if (kind > 129)
2346                      kind = 129;
2347                   jjCheckNAddStates(43, 45);
2348                   break;
2349                case 1:
2350                   if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 129)
2351                      kind = 129;
2352                   break;
2353                default : break;
2354             }
2355          } while(i != startsAt);
2356       }
2357       if (kind != 0x7fffffff)
2358       {
2359          jjmatchedKind = kind;
2360          jjmatchedPos = curPos;
2361          kind = 0x7fffffff;
2362       }
2363       ++curPos;
2364       if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
2365          return curPos;
2366       try { curChar = input_stream.readChar(); }
2367       catch(java.io.IOException e) { return curPos; }
2368    }
2369 }
2370 static final int[] jjnextStates = {
2371    67, 81, 33, 34, 35, 18, 19, 20, 94, 83, 95, 88, 96, 83, 88, 91, 
2372    68, 69, 71, 99, 102, 53, 57, 15, 16, 21, 22, 25, 29, 31, 36, 37, 
2373    40, 44, 46, 74, 78, 86, 87, 89, 90, 72, 73, 0, 1, 3, 
2374 };
2375 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
2376 {
2377    switch(hiByte)
2378    {
2379       case 22:
2380          return ((jjbitVec0[i2] & l2) != 0L);
2381       case 24:
2382          return ((jjbitVec1[i2] & l2) != 0L);
2383       case 32:
2384          return ((jjbitVec2[i2] & l2) != 0L);
2385       case 48:
2386          return ((jjbitVec3[i2] & l2) != 0L);
2387       default :
2388          return false;
2389    }
2390 }
2391 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
2392 {
2393    switch(hiByte)
2394    {
2395       case 0:
2396          return ((jjbitVec6[i2] & l2) != 0L);
2397       case 32:
2398          return ((jjbitVec7[i2] & l2) != 0L);
2399       default :
2400          if ((jjbitVec4[i1] & l1) != 0L)
2401             return true;
2402          return false;
2403    }
2404 }
2405 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
2406 {
2407    switch(hiByte)
2408    {
2409       case 0:
2410          return ((jjbitVec6[i2] & l2) != 0L);
2411       default :
2412          if ((jjbitVec8[i1] & l1) != 0L)
2413             return true;
2414          return false;
2415    }
2416 }
2417 private static final boolean jjCanMove_3(int hiByte, int i1, int i2, long l1, long l2)
2418 {
2419    switch(hiByte)
2420    {
2421       case 32:
2422          return ((jjbitVec9[i2] & l2) != 0L);
2423       default :
2424          return false;
2425    }
2426 }
2427 private static final boolean jjCanMove_4(int hiByte, int i1, int i2, long l1, long l2)
2428 {
2429    switch(hiByte)
2430    {
2431       case 0:
2432          return ((jjbitVec12[i2] & l2) != 0L);
2433       case 2:
2434          return ((jjbitVec13[i2] & l2) != 0L);
2435       case 3:
2436          return ((jjbitVec14[i2] & l2) != 0L);
2437       case 4:
2438          return ((jjbitVec15[i2] & l2) != 0L);
2439       case 5:
2440          return ((jjbitVec16[i2] & l2) != 0L);
2441       case 6:
2442          return ((jjbitVec17[i2] & l2) != 0L);
2443       case 7:
2444          return ((jjbitVec18[i2] & l2) != 0L);
2445       case 9:
2446          return ((jjbitVec19[i2] & l2) != 0L);
2447       case 10:
2448          return ((jjbitVec20[i2] & l2) != 0L);
2449       case 11:
2450          return ((jjbitVec21[i2] & l2) != 0L);
2451       case 12:
2452          return ((jjbitVec22[i2] & l2) != 0L);
2453       case 13:
2454          return ((jjbitVec23[i2] & l2) != 0L);
2455       case 14:
2456          return ((jjbitVec24[i2] & l2) != 0L);
2457       case 15:
2458          return ((jjbitVec25[i2] & l2) != 0L);
2459       case 16:
2460          return ((jjbitVec26[i2] & l2) != 0L);
2461       case 17:
2462          return ((jjbitVec27[i2] & l2) != 0L);
2463       case 18:
2464          return ((jjbitVec28[i2] & l2) != 0L);
2465       case 19:
2466          return ((jjbitVec29[i2] & l2) != 0L);
2467       case 20:
2468          return ((jjbitVec8[i2] & l2) != 0L);
2469       case 22:
2470          return ((jjbitVec30[i2] & l2) != 0L);
2471       case 23:
2472          return ((jjbitVec31[i2] & l2) != 0L);
2473       case 24:
2474          return ((jjbitVec32[i2] & l2) != 0L);
2475       case 30:
2476          return ((jjbitVec33[i2] & l2) != 0L);
2477       case 31:
2478          return ((jjbitVec34[i2] & l2) != 0L);
2479       case 32:
2480          return ((jjbitVec35[i2] & l2) != 0L);
2481       case 33:
2482          return ((jjbitVec36[i2] & l2) != 0L);
2483       case 48:
2484          return ((jjbitVec37[i2] & l2) != 0L);
2485       case 49:
2486          return ((jjbitVec38[i2] & l2) != 0L);
2487       case 77:
2488          return ((jjbitVec39[i2] & l2) != 0L);
2489       case 159:
2490          return ((jjbitVec40[i2] & l2) != 0L);
2491       case 164:
2492          return ((jjbitVec41[i2] & l2) != 0L);
2493       case 215:
2494          return ((jjbitVec42[i2] & l2) != 0L);
2495       case 250:
2496          return ((jjbitVec43[i2] & l2) != 0L);
2497       case 251:
2498          return ((jjbitVec44[i2] & l2) != 0L);
2499       case 253:
2500          return ((jjbitVec45[i2] & l2) != 0L);
2501       case 254:
2502          return ((jjbitVec46[i2] & l2) != 0L);
2503       case 255:
2504          return ((jjbitVec47[i2] & l2) != 0L);
2505       default :
2506          if ((jjbitVec11[i1] & l1) != 0L)
2507             if ((jjbitVec3[i2] & l2) == 0L)
2508                return false;
2509             else
2510             return true;
2511          if ((jjbitVec10[i1] & l1) != 0L)
2512             return true;
2513          return false;
2514    }
2515 }
2516 private static final boolean jjCanMove_5(int hiByte, int i1, int i2, long l1, long l2)
2517 {
2518    switch(hiByte)
2519    {
2520       case 0:
2521          return ((jjbitVec12[i2] & l2) != 0L);
2522       case 2:
2523          return ((jjbitVec13[i2] & l2) != 0L);
2524       case 3:
2525          return ((jjbitVec48[i2] & l2) != 0L);
2526       case 4:
2527          return ((jjbitVec49[i2] & l2) != 0L);
2528       case 5:
2529          return ((jjbitVec50[i2] & l2) != 0L);
2530       case 6:
2531          return ((jjbitVec51[i2] & l2) != 0L);
2532       case 7:
2533          return ((jjbitVec52[i2] & l2) != 0L);
2534       case 9:
2535          return ((jjbitVec53[i2] & l2) != 0L);
2536       case 10:
2537          return ((jjbitVec54[i2] & l2) != 0L);
2538       case 11:
2539          return ((jjbitVec55[i2] & l2) != 0L);
2540       case 12:
2541          return ((jjbitVec56[i2] & l2) != 0L);
2542       case 13:
2543          return ((jjbitVec57[i2] & l2) != 0L);
2544       case 14:
2545          return ((jjbitVec58[i2] & l2) != 0L);
2546       case 15:
2547          return ((jjbitVec59[i2] & l2) != 0L);
2548       case 16:
2549          return ((jjbitVec60[i2] & l2) != 0L);
2550       case 17:
2551          return ((jjbitVec27[i2] & l2) != 0L);
2552       case 18:
2553          return ((jjbitVec28[i2] & l2) != 0L);
2554       case 19:
2555          return ((jjbitVec61[i2] & l2) != 0L);
2556       case 20:
2557          return ((jjbitVec8[i2] & l2) != 0L);
2558       case 22:
2559          return ((jjbitVec30[i2] & l2) != 0L);
2560       case 23:
2561          return ((jjbitVec62[i2] & l2) != 0L);
2562       case 24:
2563          return ((jjbitVec63[i2] & l2) != 0L);
2564       case 25:
2565          return ((jjbitVec64[i2] & l2) != 0L);
2566       case 26:
2567          return ((jjbitVec65[i2] & l2) != 0L);
2568       case 29:
2569          return ((jjbitVec66[i2] & l2) != 0L);
2570       case 30:
2571          return ((jjbitVec33[i2] & l2) != 0L);
2572       case 31:
2573          return ((jjbitVec34[i2] & l2) != 0L);
2574       case 32:
2575          return ((jjbitVec67[i2] & l2) != 0L);
2576       case 33:
2577          return ((jjbitVec36[i2] & l2) != 0L);
2578       case 48:
2579          return ((jjbitVec68[i2] & l2) != 0L);
2580       case 49:
2581          return ((jjbitVec38[i2] & l2) != 0L);
2582       case 77:
2583          return ((jjbitVec39[i2] & l2) != 0L);
2584       case 159:
2585          return ((jjbitVec40[i2] & l2) != 0L);
2586       case 164:
2587          return ((jjbitVec41[i2] & l2) != 0L);
2588       case 168:
2589          return ((jjbitVec69[i2] & l2) != 0L);
2590       case 215:
2591          return ((jjbitVec42[i2] & l2) != 0L);
2592       case 250:
2593          return ((jjbitVec43[i2] & l2) != 0L);
2594       case 251:
2595          return ((jjbitVec70[i2] & l2) != 0L);
2596       case 253:
2597          return ((jjbitVec45[i2] & l2) != 0L);
2598       case 254:
2599          return ((jjbitVec71[i2] & l2) != 0L);
2600       case 255:
2601          return ((jjbitVec72[i2] & l2) != 0L);
2602       default :
2603          if ((jjbitVec11[i1] & l1) != 0L)
2604             if ((jjbitVec3[i2] & l2) == 0L)
2605                return false;
2606             else
2607             return true;
2608          if ((jjbitVec10[i1] & l1) != 0L)
2609             return true;
2610          return false;
2611    }
2612 }
2613 private static final boolean jjCanMove_6(int hiByte, int i1, int i2, long l1, long l2)
2614 {
2615    switch(hiByte)
2616    {
2617       case 3:
2618          return ((jjbitVec73[i2] & l2) != 0L);
2619       case 4:
2620          return ((jjbitVec74[i2] & l2) != 0L);
2621       case 5:
2622          return ((jjbitVec75[i2] & l2) != 0L);
2623       case 6:
2624          return ((jjbitVec76[i2] & l2) != 0L);
2625       case 7:
2626          return ((jjbitVec77[i2] & l2) != 0L);
2627       case 9:
2628          return ((jjbitVec78[i2] & l2) != 0L);
2629       case 10:
2630          return ((jjbitVec79[i2] & l2) != 0L);
2631       case 11:
2632          return ((jjbitVec80[i2] & l2) != 0L);
2633       case 12:
2634          return ((jjbitVec81[i2] & l2) != 0L);
2635       case 13:
2636          return ((jjbitVec82[i2] & l2) != 0L);
2637       case 14:
2638          return ((jjbitVec83[i2] & l2) != 0L);
2639       case 15:
2640          return ((jjbitVec84[i2] & l2) != 0L);
2641       case 16:
2642          return ((jjbitVec85[i2] & l2) != 0L);
2643       case 23:
2644          return ((jjbitVec86[i2] & l2) != 0L);
2645       case 24:
2646          return ((jjbitVec87[i2] & l2) != 0L);
2647       case 25:
2648          return ((jjbitVec64[i2] & l2) != 0L);
2649       case 26:
2650          return ((jjbitVec65[i2] & l2) != 0L);
2651       case 29:
2652          return ((jjbitVec66[i2] & l2) != 0L);
2653       case 32:
2654          return ((jjbitVec88[i2] & l2) != 0L);
2655       case 48:
2656          return ((jjbitVec89[i2] & l2) != 0L);
2657       case 168:
2658          return ((jjbitVec69[i2] & l2) != 0L);
2659       case 251:
2660          return ((jjbitVec90[i2] & l2) != 0L);
2661       case 254:
2662          return ((jjbitVec91[i2] & l2) != 0L);
2663       default :
2664          return false;
2665    }
2666 }
2667 private static final boolean jjCanMove_7(int hiByte, int i1, int i2, long l1, long l2)
2668 {
2669    switch(hiByte)
2670    {
2671       case 9:
2672          return ((jjbitVec92[i2] & l2) != 0L);
2673       case 10:
2674          return ((jjbitVec93[i2] & l2) != 0L);
2675       case 11:
2676          return ((jjbitVec94[i2] & l2) != 0L);
2677       case 12:
2678          return ((jjbitVec95[i2] & l2) != 0L);
2679       case 13:
2680          return ((jjbitVec96[i2] & l2) != 0L);
2681       case 15:
2682          return ((jjbitVec97[i2] & l2) != 0L);
2683       case 16:
2684          return ((jjbitVec98[i2] & l2) != 0L);
2685       case 23:
2686          return ((jjbitVec99[i2] & l2) != 0L);
2687       case 25:
2688          return ((jjbitVec64[i2] & l2) != 0L);
2689       case 26:
2690          return ((jjbitVec65[i2] & l2) != 0L);
2691       case 29:
2692          return ((jjbitVec66[i2] & l2) != 0L);
2693       case 168:
2694          return ((jjbitVec69[i2] & l2) != 0L);
2695       default :
2696          return false;
2697    }
2698 }
2699 private static final boolean jjCanMove_8(int hiByte, int i1, int i2, long l1, long l2)
2700 {
2701    switch(hiByte)
2702    {
2703       case 3:
2704          return ((jjbitVec73[i2] & l2) != 0L);
2705       case 4:
2706          return ((jjbitVec74[i2] & l2) != 0L);
2707       case 5:
2708          return ((jjbitVec75[i2] & l2) != 0L);
2709       case 6:
2710          return ((jjbitVec76[i2] & l2) != 0L);
2711       case 7:
2712          return ((jjbitVec77[i2] & l2) != 0L);
2713       case 9:
2714          return ((jjbitVec78[i2] & l2) != 0L);
2715       case 10:
2716          return ((jjbitVec100[i2] & l2) != 0L);
2717       case 11:
2718          return ((jjbitVec80[i2] & l2) != 0L);
2719       case 12:
2720          return ((jjbitVec81[i2] & l2) != 0L);
2721       case 13:
2722          return ((jjbitVec82[i2] & l2) != 0L);
2723       case 14:
2724          return ((jjbitVec83[i2] & l2) != 0L);
2725       case 15:
2726          return ((jjbitVec84[i2] & l2) != 0L);
2727       case 16:
2728          return ((jjbitVec85[i2] & l2) != 0L);
2729       case 23:
2730          return ((jjbitVec86[i2] & l2) != 0L);
2731       case 24:
2732          return ((jjbitVec87[i2] & l2) != 0L);
2733       case 32:
2734          return ((jjbitVec88[i2] & l2) != 0L);
2735       case 48:
2736          return ((jjbitVec89[i2] & l2) != 0L);
2737       case 251:
2738          return ((jjbitVec90[i2] & l2) != 0L);
2739       case 254:
2740          return ((jjbitVec91[i2] & l2) != 0L);
2741       default :
2742          return false;
2743    }
2744 }
2745 private static final boolean jjCanMove_9(int hiByte, int i1, int i2, long l1, long l2)
2746 {
2747    switch(hiByte)
2748    {
2749       case 6:
2750          return ((jjbitVec105[i2] & l2) != 0L);
2751       case 11:
2752          return ((jjbitVec106[i2] & l2) != 0L);
2753       case 13:
2754          return ((jjbitVec107[i2] & l2) != 0L);
2755       case 14:
2756          return ((jjbitVec108[i2] & l2) != 0L);
2757       case 15:
2758          return ((jjbitVec109[i2] & l2) != 0L);
2759       case 16:
2760          return ((jjbitVec110[i2] & l2) != 0L);
2761       case 19:
2762          return ((jjbitVec111[i2] & l2) != 0L);
2763       case 23:
2764          return ((jjbitVec112[i2] & l2) != 0L);
2765       default :
2766          if ((jjbitVec103[i1] & l1) != 0L)
2767             if ((jjbitVec104[i2] & l2) == 0L)
2768                return false;
2769             else
2770             return true;
2771          if ((jjbitVec101[i1] & l1) != 0L)
2772             if ((jjbitVec102[i2] & l2) == 0L)
2773                return false;
2774             else
2775             return true;
2776          return false;
2777    }
2778 }
2779 private static final boolean jjCanMove_10(int hiByte, int i1, int i2, long l1, long l2)
2780 {
2781    switch(hiByte)
2782    {
2783       case 32:
2784          return ((jjbitVec113[i2] & l2) != 0L);
2785       case 48:
2786          return ((jjbitVec114[i2] & l2) != 0L);
2787       case 254:
2788          return ((jjbitVec115[i2] & l2) != 0L);
2789       case 255:
2790          return ((jjbitVec116[i2] & l2) != 0L);
2791       default :
2792          return false;
2793    }
2794 }
2795 
2796 /** Token literal values. */
2797 public static final String[] jjstrLiteralImages = {
2798 null, null, null, null, null, null, null, null, null, null, null, null, null, 
2799 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2800 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2801 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2802 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2803 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2804 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2805 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2806 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
2807 null, null, null, null, null, null, };
2808 
2809 /** Lexer state names. */
2810 public static final String[] lexStateNames = {
2811    "DEFAULT",
2812    "IN_SINGLE_LINE_COMMENT",
2813    "IN_MULTI_LINE_COMMENT",
2814    "IN_JAVA_STATEMENT",
2815 };
2816 
2817 /** Lex State array. */
2818 public static final int[] jjnewLexState = {
2819    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
2820    -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, 
2821    -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, 
2822    -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, 
2823    -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, 
2824    -1, -1, -1, 3, 0, -1, 
2825 };
2826 static final long[] jjtoToken = {
2827    0xfffffffffffe0001L, 0x7f030061ffffffffL, 0x2L, 
2828 };
2829 static final long[] jjtoSkip = {
2830    0xcffeL, 0x0L, 0x0L, 
2831 };
2832 static final long[] jjtoSpecial = {
2833    0xcffeL, 0x0L, 0x0L, 
2834 };
2835 static final long[] jjtoMore = {
2836    0x13000L, 0x80000000000000L, 0x5L, 
2837 };
2838 protected JavaCharStream input_stream;
2839 private final int[] jjrounds = new int[106];
2840 private final int[] jjstateSet = new int[212];
2841 private final StringBuilder jjimage = new StringBuilder();
2842 private StringBuilder image = jjimage;
2843 private int jjimageLen;
2844 private int lengthOfMatch;
2845 protected char curChar;
2846 /** Constructor. */
2847 public JSParserTokenManager(JavaCharStream stream){
2848    if (JavaCharStream.staticFlag)
2849       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2850    input_stream = stream;
2851 }
2852 
2853 /** Constructor. */
2854 public JSParserTokenManager(JavaCharStream stream, int lexState){
2855    this(stream);
2856    SwitchTo(lexState);
2857 }
2858 
2859 /** Reinitialise parser. */
2860 public void ReInit(JavaCharStream stream)
2861 {
2862    jjmatchedPos = jjnewStateCnt = 0;
2863    curLexState = defaultLexState;
2864    input_stream = stream;
2865    ReInitRounds();
2866 }
2867 private void ReInitRounds()
2868 {
2869    int i;
2870    jjround = 0x80000001;
2871    for (i = 106; i-- > 0;)
2872       jjrounds[i] = 0x80000000;
2873 }
2874 
2875 /** Reinitialise parser. */
2876 public void ReInit(JavaCharStream stream, int lexState)
2877 {
2878    ReInit(stream);
2879    SwitchTo(lexState);
2880 }
2881 
2882 /** Switch to specified lex state. */
2883 public void SwitchTo(int lexState)
2884 {
2885    if (lexState >= 4 || lexState < 0)
2886       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2887    else
2888       curLexState = lexState;
2889 }
2890 
2891 protected Token jjFillToken()
2892 {
2893    final Token t;
2894    final String curTokenImage;
2895    final int beginLine;
2896    final int endLine;
2897    final int beginColumn;
2898    final int endColumn;
2899    if (jjmatchedPos < 0)
2900    {
2901       if (image == null)
2902          curTokenImage = "";
2903       else
2904          curTokenImage = image.toString();
2905       beginLine = endLine = input_stream.getBeginLine();
2906       beginColumn = endColumn = input_stream.getBeginColumn();
2907    }
2908    else
2909    {
2910       String im = jjstrLiteralImages[jjmatchedKind];
2911       curTokenImage = (im == null) ? input_stream.GetImage() : im;
2912       beginLine = input_stream.getBeginLine();
2913       beginColumn = input_stream.getBeginColumn();
2914       endLine = input_stream.getEndLine();
2915       endColumn = input_stream.getEndColumn();
2916    }
2917    t = Token.newToken(jjmatchedKind, curTokenImage);
2918 
2919    t.beginLine = beginLine;
2920    t.endLine = endLine;
2921    t.beginColumn = beginColumn;
2922    t.endColumn = endColumn;
2923 
2924    return t;
2925 }
2926 
2927 int curLexState = 0;
2928 int defaultLexState = 0;
2929 int jjnewStateCnt;
2930 int jjround;
2931 int jjmatchedPos;
2932 int jjmatchedKind;
2933 
2934 /** Get the next Token. */
2935 public Token getNextToken() 
2936 {
2937   Token specialToken = null;
2938   Token matchedToken;
2939   int curPos = 0;
2940 
2941   EOFLoop :
2942   for (;;)
2943   {
2944    try
2945    {
2946       curChar = input_stream.BeginToken();
2947    }
2948    catch(java.io.IOException e)
2949    {
2950       jjmatchedKind = 0;
2951       matchedToken = jjFillToken();
2952       matchedToken.specialToken = specialToken;
2953       return matchedToken;
2954    }
2955    image = jjimage;
2956    image.setLength(0);
2957    jjimageLen = 0;
2958 
2959    for (;;)
2960    {
2961      switch(curLexState)
2962      {
2963        case 0:
2964          jjmatchedKind = 0x7fffffff;
2965          jjmatchedPos = 0;
2966          curPos = jjMoveStringLiteralDfa0_0();
2967          break;
2968        case 1:
2969          jjmatchedKind = 14;
2970          jjmatchedPos = -1;
2971          curPos = 0;
2972          curPos = jjMoveStringLiteralDfa0_1();
2973          if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 16))
2974          {
2975             jjmatchedKind = 16;
2976             jjmatchedPos = 0;
2977          }
2978          break;
2979        case 2:
2980          jjmatchedKind = 0x7fffffff;
2981          jjmatchedPos = 0;
2982          curPos = jjMoveStringLiteralDfa0_2();
2983          if (jjmatchedPos == 0 && jjmatchedKind > 16)
2984          {
2985             jjmatchedKind = 16;
2986          }
2987          break;
2988        case 3:
2989          jjmatchedKind = 129;
2990          jjmatchedPos = -1;
2991          curPos = 0;
2992          curPos = jjMoveStringLiteralDfa0_3();
2993          if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 130))
2994          {
2995             jjmatchedKind = 130;
2996             jjmatchedPos = 0;
2997          }
2998          break;
2999      }
3000      if (jjmatchedKind != 0x7fffffff)
3001      {
3002         if (jjmatchedPos + 1 < curPos)
3003            input_stream.backup(curPos - jjmatchedPos - 1);
3004         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3005         {
3006            matchedToken = jjFillToken();
3007            matchedToken.specialToken = specialToken;
3008            TokenLexicalActions(matchedToken);
3009        if (jjnewLexState[jjmatchedKind] != -1)
3010          curLexState = jjnewLexState[jjmatchedKind];
3011            return matchedToken;
3012         }
3013         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3014         {
3015            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3016            {
3017               matchedToken = jjFillToken();
3018               if (specialToken == null)
3019                  specialToken = matchedToken;
3020               else
3021               {
3022                  matchedToken.specialToken = specialToken;
3023                  specialToken = (specialToken.next = matchedToken);
3024               }
3025               SkipLexicalActions(matchedToken);
3026            }
3027            else
3028               SkipLexicalActions(null);
3029          if (jjnewLexState[jjmatchedKind] != -1)
3030            curLexState = jjnewLexState[jjmatchedKind];
3031            continue EOFLoop;
3032         }
3033         jjimageLen += jjmatchedPos + 1;
3034       if (jjnewLexState[jjmatchedKind] != -1)
3035         curLexState = jjnewLexState[jjmatchedKind];
3036         curPos = 0;
3037         jjmatchedKind = 0x7fffffff;
3038         try {
3039            curChar = input_stream.readChar();
3040            continue;
3041         }
3042         catch (java.io.IOException e1) { }
3043      }
3044      int error_line = input_stream.getEndLine();
3045      int error_column = input_stream.getEndColumn();
3046      String error_after = null;
3047      boolean EOFSeen = false;
3048      try { input_stream.readChar(); input_stream.backup(1); }
3049      catch (java.io.IOException e1) {
3050         EOFSeen = true;
3051         error_after = curPos <= 1 ? "" : input_stream.GetImage();
3052         if (curChar == '\n' || curChar == '\r') {
3053            error_line++;
3054            error_column = 0;
3055         }
3056         else
3057            error_column++;
3058      }
3059      if (!EOFSeen) {
3060         input_stream.backup(1);
3061         error_after = curPos <= 1 ? "" : input_stream.GetImage();
3062      }
3063      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3064    }
3065   }
3066 }
3067 
3068 void SkipLexicalActions(Token matchedToken)
3069 {
3070    switch(jjmatchedKind)
3071    {
3072       default :
3073          break;
3074    }
3075 }
3076 void TokenLexicalActions(Token matchedToken)
3077 {
3078    switch(jjmatchedKind)
3079    {
3080       default :
3081          break;
3082    }
3083 }
3084 private void jjCheckNAdd(int state)
3085 {
3086    if (jjrounds[state] != jjround)
3087    {
3088       jjstateSet[jjnewStateCnt++] = state;
3089       jjrounds[state] = jjround;
3090    }
3091 }
3092 private void jjAddStates(int start, int end)
3093 {
3094    do {
3095       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
3096    } while (start++ != end);
3097 }
3098 private void jjCheckNAddTwoStates(int state1, int state2)
3099 {
3100    jjCheckNAdd(state1);
3101    jjCheckNAdd(state2);
3102 }
3103 
3104 private void jjCheckNAddStates(int start, int end)
3105 {
3106    do {
3107       jjCheckNAdd(jjnextStates[start]);
3108    } while (start++ != end);
3109 }
3110 
3111 }