CppParserTokenManager.java
0001 /* Generated By:JavaCC: Do not edit this line. CppParserTokenManager.java */
0002 package net.sourceforge.pmd.lang.cpp.ast;
0003 import net.sourceforge.pmd.lang.ast.CharStream;
0004 import net.sourceforge.pmd.lang.ast.TokenMgrError;
0005 
0006 /** Token Manager. */
0007 public class CppParserTokenManager extends net.sourceforge.pmd.lang.ast.AbstractTokenManager implements CppParserConstants
0008 {
0009 
0010   /** Debug output. */
0011   public  java.io.PrintStream debugStream = System.out;
0012   /** Set debug output. */
0013   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
0014 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2)
0015 {
0016    switch (pos)
0017    {
0018       case 0:
0019          if ((active1 & 0x3ffffffffffff0L!= 0L || (active2 & 0x40L!= 0L)
0020          {
0021             jjmatchedKind = 135;
0022             return 29;
0023          }
0024          if ((active0 & 0x40000000L!= 0L || (active1 & 0x5L!= 0L)
0025             return 1;
0026          return -1;
0027       case 1:
0028          if ((active1 & 0x3fffffffbf9ff0L!= 0L || (active2 & 0x40L!= 0L)
0029          {
0030             if (jjmatchedPos != 1)
0031             {
0032                jjmatchedKind = 135;
0033                jjmatchedPos = 1;
0034             }
0035             return 29;
0036          }
0037          if ((active1 & 0x406000L!= 0L)
0038             return 29;
0039          return -1;
0040       case 2:
0041          if ((active1 & 0x3ffbfffab7dff0L!= 0L || (active2 & 0x40L!= 0L)
0042          {
0043             jjmatchedKind = 135;
0044             jjmatchedPos = 2;
0045             return 29;
0046          }
0047          if ((active1 & 0x40005080000L!= 0L)
0048             return 29;
0049          return -1;
0050       case 3:
0051          if ((active1 & 0x3779fff8965ea0L!= 0L || (active2 & 0x40L!= 0L)
0052          {
0053             jjmatchedKind = 135;
0054             jjmatchedPos = 3;
0055             return 29;
0056          }
0057          if ((active1 & 0x8820002218150L!= 0L)
0058             return 29;
0059          return -1;
0060       case 4:
0061          if ((active1 & 0x569bdf8925c00L!= 0L || (active2 & 0x40L!= 0L)
0062          {
0063             jjmatchedKind = 135;
0064             jjmatchedPos = 4;
0065             return 29;
0066          }
0067          if ((active1 & 0x321042000402a0L!= 0L)
0068             return 29;
0069          return -1;
0070       case 5:
0071          if ((active1 & 0x56900d8000c00L!= 0L || (active2 & 0x40L!= 0L)
0072          {
0073             jjmatchedKind = 135;
0074             jjmatchedPos = 5;
0075             return 29;
0076          }
0077          if ((active1 & 0xbd20925000L!= 0L)
0078             return 29;
0079          return -1;
0080       case 6:
0081          if ((active1 & 0x52100d0000400L!= 0L)
0082          {
0083             jjmatchedKind = 135;
0084             jjmatchedPos = 6;
0085             return 29;
0086          }
0087          if ((active1 & 0x480008000800L!= 0L || (active2 & 0x40L!= 0L)
0088             return 29;
0089          return -1;
0090       case 7:
0091          if ((active1 & 0x50000000L!= 0L)
0092          {
0093             jjmatchedKind = 135;
0094             jjmatchedPos = 7;
0095             return 29;
0096          }
0097          if ((active1 & 0x5210080000400L!= 0L)
0098             return 29;
0099          return -1;
0100       case 8:
0101          if ((active1 & 0x40000000L!= 0L)
0102          {
0103             jjmatchedKind = 135;
0104             jjmatchedPos = 8;
0105             return 29;
0106          }
0107          if ((active1 & 0x10000000L!= 0L)
0108             return 29;
0109          return -1;
0110       default :
0111          return -1;
0112    }
0113 }
0114 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
0115 {
0116    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
0117 }
0118 private int jjStopAtPos(int pos, int kind)
0119 {
0120    jjmatchedKind = kind;
0121    jjmatchedPos = pos;
0122    return pos + 1;
0123 }
0124 private int jjMoveStringLiteralDfa0_0()
0125 {
0126    switch(curChar)
0127    {
0128       case 13:
0129          return jjMoveStringLiteralDfa1_0(0x10L0x0L0x0L);
0130       case 33:
0131          jjmatchedKind = 63;
0132          return jjMoveStringLiteralDfa1_0(0x1000000000000L0x0L0x0L);
0133       case 35:
0134          return jjStopAtPos(08);
0135       case 37:
0136          jjmatchedKind = 59;
0137          return jjMoveStringLiteralDfa1_0(0x400000000L0x0L0x0L);
0138       case 38:
0139          jjmatchedKind = 46;
0140          return jjMoveStringLiteralDfa1_0(0x88000000000L0x0L0x0L);
0141       case 40:
0142          return jjStopAtPos(023);
0143       case 41:
0144          return jjStopAtPos(024);
0145       case 42:
0146          jjmatchedKind = 57;
0147          return jjMoveStringLiteralDfa1_0(0x100000000L0x0L0x0L);
0148       case 43:
0149          jjmatchedKind = 55;
0150          return jjMoveStringLiteralDfa1_0(0x1000000800000000L0x0L0x0L);
0151       case 44:
0152          return jjStopAtPos(028);
0153       case 45:
0154          jjmatchedKind = 56;
0155          return jjMoveStringLiteralDfa1_0(0x2000001000000000L0xaL0x0L);
0156       case 46:
0157          jjmatchedKind = 64;
0158          return jjMoveStringLiteralDfa1_0(0x40000000L0x4L0x0L);
0159       case 47:
0160          jjmatchedKind = 58;
0161          return jjMoveStringLiteralDfa1_0(0x2000000c0L0x0L0x0L);
0162       case 58:
0163          jjmatchedKind = 26;
0164          return jjMoveStringLiteralDfa1_0(0x2000000L0x0L0x0L);
0165       case 59:
0166          return jjStopAtPos(027);
0167       case 60:
0168          jjmatchedKind = 49;
0169          return jjMoveStringLiteralDfa1_0(0x28002000000000L0x0L0x0L);
0170       case 61:
0171          jjmatchedKind = 31;
0172          return jjMoveStringLiteralDfa1_0(0x800000000000L0x0L0x0L);
0173       case 62:
0174          jjmatchedKind = 50;
0175          return jjMoveStringLiteralDfa1_0(0x50004000000000L0x0L0x0L);
0176       case 63:
0177          return jjStopAtPos(029);
0178       case 91:
0179          return jjStopAtPos(021);
0180       case 93:
0181          return jjStopAtPos(022);
0182       case 94:
0183          jjmatchedKind = 45;
0184          return jjMoveStringLiteralDfa1_0(0x10000000000L0x0L0x0L);
0185       case 97:
0186          return jjMoveStringLiteralDfa1_0(0x0L0x10L0x0L);
0187       case 98:
0188          return jjMoveStringLiteralDfa1_0(0x0L0x20L0x0L);
0189       case 99:
0190          return jjMoveStringLiteralDfa1_0(0x0L0x40000007c0L0x0L);
0191       case 100:
0192          return jjMoveStringLiteralDfa1_0(0x0L0x7800L0x0L);
0193       case 101:
0194          return jjMoveStringLiteralDfa1_0(0x0L0x38000L0x0L);
0195       case 102:
0196          return jjMoveStringLiteralDfa1_0(0x0L0x100000001c0000L0x40L);
0197       case 103:
0198          return jjMoveStringLiteralDfa1_0(0x0L0x200000L0x0L);
0199       case 105:
0200          return jjMoveStringLiteralDfa1_0(0x0L0x1c00000L0x0L);
0201       case 108:
0202          return jjMoveStringLiteralDfa1_0(0x0L0x2000000L0x0L);
0203       case 110:
0204          return jjMoveStringLiteralDfa1_0(0x0L0x4000000L0x0L);
0205       case 111:
0206          return jjMoveStringLiteralDfa1_0(0x0L0x4000000000000L0x0L);
0207       case 112:
0208          return jjMoveStringLiteralDfa1_0(0x0L0x38000000L0x0L);
0209       case 114:
0210          return jjMoveStringLiteralDfa1_0(0x0L0x1c0000000L0x0L);
0211       case 115:
0212          return jjMoveStringLiteralDfa1_0(0x0L0xbe00000000L0x0L);
0213       case 116:
0214          return jjMoveStringLiteralDfa1_0(0x0L0x280f0000000000L0x0L);
0215       case 117:
0216          return jjMoveStringLiteralDfa1_0(0x0L0x300000000000L0x0L);
0217       case 118:
0218          return jjMoveStringLiteralDfa1_0(0x0L0x1c00000000000L0x0L);
0219       case 119:
0220          return jjMoveStringLiteralDfa1_0(0x0L0x2000000000000L0x0L);
0221       case 123:
0222          return jjStopAtPos(019);
0223       case 124:
0224          jjmatchedKind = 44;
0225          return jjMoveStringLiteralDfa1_0(0x60000000000L0x0L0x0L);
0226       case 125:
0227          return jjStopAtPos(020);
0228       case 126:
0229          return jjStopAtPos(062);
0230       default :
0231          return jjMoveNfa_0(280);
0232    }
0233 }
0234 private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2)
0235 {
0236    try curChar = input_stream.readChar()}
0237    catch(java.io.IOException e) {
0238       jjStopStringLiteralDfa_0(0, active0, active1, active2);
0239       return 1;
0240    }
0241    switch(curChar)
0242    {
0243       case 10:
0244          if ((active0 & 0x10L!= 0L)
0245             return jjStopAtPos(14);
0246          break;
0247       case 38:
0248          if ((active0 & 0x80000000000L!= 0L)
0249             return jjStopAtPos(143);
0250          break;
0251       case 42:
0252          if ((active0 & 0x80L!= 0L)
0253             return jjStopAtPos(17);
0254          else if ((active1 & 0x4L!= 0L)
0255             return jjStopAtPos(166);
0256          break;
0257       case 43:
0258          if ((active0 & 0x1000000000000000L!= 0L)
0259             return jjStopAtPos(160);
0260          break;
0261       case 45:
0262          if ((active0 & 0x2000000000000000L!= 0L)
0263             return jjStopAtPos(161);
0264          break;
0265       case 46:
0266          return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L, active2, 0L);
0267       case 47:
0268          if ((active0 & 0x40L!= 0L)
0269             return jjStopAtPos(16);
0270          break;
0271       case 58:
0272          if ((active0 & 0x2000000L!= 0L)
0273             return jjStopAtPos(125);
0274          break;
0275       case 60:
0276          if ((active0 & 0x20000000000000L!= 0L)
0277          {
0278             jjmatchedKind = 53;
0279             jjmatchedPos = 1;
0280          }
0281          return jjMoveStringLiteralDfa2_0(active0, 0x2000000000L, active1, 0L, active2, 0L);
0282       case 61:
0283          if ((active0 & 0x100000000L!= 0L)
0284             return jjStopAtPos(132);
0285          else if ((active0 & 0x200000000L!= 0L)
0286             return jjStopAtPos(133);
0287          else if ((active0 & 0x400000000L!= 0L)
0288             return jjStopAtPos(134);
0289          else if ((active0 & 0x800000000L!= 0L)
0290             return jjStopAtPos(135);
0291          else if ((active0 & 0x1000000000L!= 0L)
0292             return jjStopAtPos(136);
0293          else if ((active0 & 0x8000000000L!= 0L)
0294             return jjStopAtPos(139);
0295          else if ((active0 & 0x10000000000L!= 0L)
0296             return jjStopAtPos(140);
0297          else if ((active0 & 0x20000000000L!= 0L)
0298             return jjStopAtPos(141);
0299          else if ((active0 & 0x800000000000L!= 0L)
0300             return jjStopAtPos(147);
0301          else if ((active0 & 0x1000000000000L!= 0L)
0302             return jjStopAtPos(148);
0303          else if ((active0 & 0x8000000000000L!= 0L)
0304             return jjStopAtPos(151);
0305          else if ((active0 & 0x10000000000000L!= 0L)
0306             return jjStopAtPos(152);
0307          break;
0308       case 62:
0309          if ((active0 & 0x40000000000000L!= 0L)
0310          {
0311             jjmatchedKind = 54;
0312             jjmatchedPos = 1;
0313          }
0314          else if ((active1 & 0x2L!= 0L)
0315          {
0316             jjmatchedKind = 65;
0317             jjmatchedPos = 1;
0318          }
0319          return jjMoveStringLiteralDfa2_0(active0, 0x4000000000L, active1, 0x8L, active2, 0L);
0320       case 97:
0321          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100000000000c0L, active2, 0L);
0322       case 101:
0323          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x101c4001800L, active2, 0L);
0324       case 102:
0325          if ((active1 & 0x400000L!= 0L)
0326             return jjStartNfaWithStates_0(18629);
0327          break;
0328       case 104:
0329          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x22020200000100L, active2, 0L);
0330       case 105:
0331          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x400c00000000L, active2, 0x40L);
0332       case 108:
0333          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000048000L, active2, 0L);
0334       case 110:
0335          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300001810000L, active2, 0L);
0336       case 111:
0337          if ((active1 & 0x2000L!= 0L)
0338          {
0339             jjmatchedKind = 77;
0340             jjmatchedPos = 1;
0341          }
0342          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1800002284600L, active2, 0L);
0343       case 112:
0344          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000000000L, active2, 0L);
0345       case 114:
0346          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8040018100020L, active2, 0L);
0347       case 116:
0348          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x3000000000L, active2, 0L);
0349       case 117:
0350          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000010L, active2, 0L);
0351       case 119:
0352          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000000L, active2, 0L);
0353       case 120:
0354          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000L, active2, 0L);
0355       case 121:
0356          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
0357       case 124:
0358          if ((active0 & 0x40000000000L!= 0L)
0359             return jjStopAtPos(142);
0360          break;
0361       default :
0362          break;
0363    }
0364    return jjStartNfa_0(0, active0, active1, active2);
0365 }
0366 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2)
0367 {
0368    if (((active0 &= old0(active1 &= old1(active2 &= old2)) == 0L)
0369       return jjStartNfa_0(0, old0, old1, old2);
0370    try curChar = input_stream.readChar()}
0371    catch(java.io.IOException e) {
0372       jjStopStringLiteralDfa_0(1, active0, active1, active2);
0373       return 2;
0374    }
0375    switch(curChar)
0376    {
0377       case 42:
0378          if ((active1 & 0x8L!= 0L)
0379             return jjStopAtPos(267);
0380          break;
0381       case 46:
0382          if ((active0 & 0x40000000L!= 0L)
0383             return jjStopAtPos(230);
0384          break;
0385       case 61:
0386          if ((active0 & 0x2000000000L!= 0L)
0387             return jjStopAtPos(237);
0388          else if ((active0 & 0x4000000000L!= 0L)
0389             return jjStopAtPos(238);
0390          break;
0391       case 97:
0392          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x5000000100L, active2, 0L);
0393       case 98:
0394          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000000L, active2, 0L);
0395       case 100:
0396          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x40000000L, active2, 0L);
0397       case 101:
0398          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4000000000020L, active2, 0L);
0399       case 102:
0400          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800L, active2, 0L);
0401       case 103:
0402          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x480000000L, active2, 0L);
0403       case 105:
0404          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2928008100000L, active2, 0L);
0405       case 108:
0406          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x11000000801000L, active2, 0L);
0407       case 109:
0408          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x10000000000L, active2, 0L);
0409       case 110:
0410          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2000600L, active2, 0x40L);
0411       case 111:
0412          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x210040000L, active2, 0L);
0413       case 112:
0414          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
0415       case 114:
0416          if ((active1 & 0x80000L!= 0L)
0417             return jjStartNfaWithStates_0(28329);
0418          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20402000000000L, active2, 0L);
0419       case 115:
0420          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000008040L, active2, 0L);
0421       case 116:
0422          if ((active1 & 0x1000000L!= 0L)
0423             return jjStartNfaWithStates_0(28829);
0424          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100220090L, active2, 0L);
0425       case 117:
0426          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000014000L, active2, 0L);
0427       case 119:
0428          if ((active1 & 0x4000000L!= 0L)
0429             return jjStartNfaWithStates_0(29029);
0430          break;
0431       case 121:
0432          if ((active1 & 0x40000000000L!= 0L)
0433             return jjStartNfaWithStates_0(210629);
0434          break;
0435       case 122:
0436          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800000000L, active2, 0L);
0437       default :
0438          break;
0439    }
0440    return jjStartNfa_0(1, active0, active1, active2);
0441 }
0442 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2)
0443 {
0444    if (((active0 &= old0(active1 &= old1(active2 &= old2)) == 0L)
0445       return jjStartNfa_0(1, old0, old1, old2);
0446    try curChar = input_stream.readChar()}
0447    catch(java.io.IOException e) {
0448       jjStopStringLiteralDfa_0(20L, active1, active2);
0449       return 3;
0450    }
0451    switch(curChar)
0452    {
0453       case 97:
0454          return jjMoveStringLiteralDfa4_0(active1, 0x1000000040820L, active2, 0x40L);
0455       case 98:
0456          return jjMoveStringLiteralDfa4_0(active1, 0x4000L, active2, 0L);
0457       case 99:
0458          return jjMoveStringLiteralDfa4_0(active1, 0x80L, active2, 0L);
0459       case 100:
0460          if ((active1 & 0x800000000000L!= 0L)
0461             return jjStartNfaWithStates_0(311129);
0462          break;
0463       case 101:
0464          if ((active1 & 0x40L!= 0L)
0465             return jjStartNfaWithStates_0(37029);
0466          else if ((active1 & 0x8000L!= 0L)
0467             return jjStartNfaWithStates_0(37929);
0468          else if ((active1 & 0x8000000000000L!= 0L)
0469             return jjStartNfaWithStates_0(311529);
0470          return jjMoveStringLiteralDfa4_0(active1, 0x80840121000L, active2, 0L);
0471       case 103:
0472          if ((active1 & 0x2000000L!= 0L)
0473             return jjStartNfaWithStates_0(38929);
0474          break;
0475       case 105:
0476          return jjMoveStringLiteralDfa4_0(active1, 0x200080800000L, active2, 0L);
0477       case 108:
0478          return jjMoveStringLiteralDfa4_0(active1, 0x2000020000000L, active2, 0L);
0479       case 109:
0480          if ((active1 & 0x10000L!= 0L)
0481             return jjStartNfaWithStates_0(38029);
0482          break;
0483       case 110:
0484          return jjMoveStringLiteralDfa4_0(active1, 0x400000000L, active2, 0L);
0485       case 111:
0486          if ((active1 & 0x10L!= 0L)
0487             return jjStartNfaWithStates_0(36829);
0488          else if ((active1 & 0x200000L!= 0L)
0489             return jjStartNfaWithStates_0(38529);
0490          return jjMoveStringLiteralDfa4_0(active1, 0x20100000000000L, active2, 0L);
0491       case 112:
0492          return jjMoveStringLiteralDfa4_0(active1, 0x10000000000L, active2, 0L);
0493       case 114:
0494          if ((active1 & 0x100L!= 0L)
0495             return jjStartNfaWithStates_0(37229);
0496          return jjMoveStringLiteralDfa4_0(active1, 0x4000200000000L, active2, 0L);
0497       case 115:
0498          if ((active1 & 0x20000000000L!= 0L)
0499             return jjStartNfaWithStates_0(310529);
0500          return jjMoveStringLiteralDfa4_0(active1, 0x10004000000200L, active2, 0L);
0501       case 116:
0502          return jjMoveStringLiteralDfa4_0(active1, 0x409010000400L, active2, 0L);
0503       case 117:
0504          return jjMoveStringLiteralDfa4_0(active1, 0x2100000000L, active2, 0L);
0505       case 118:
0506          return jjMoveStringLiteralDfa4_0(active1, 0x8000000L, active2, 0L);
0507       default :
0508          break;
0509    }
0510    return jjStartNfa_0(20L, active1, active2);
0511 }
0512 private int jjMoveStringLiteralDfa4_0(long old1, long active1, long old2, long active2)
0513 {
0514    if (((active1 &= old1(active2 &= old2)) == 0L)
0515       return jjStartNfa_0(20L, old1, old2);
0516    try curChar = input_stream.readChar()}
0517    catch(java.io.IOException e) {
0518       jjStopStringLiteralDfa_0(30L, active1, active2);
0519       return 4;
0520    }
0521    switch(curChar)
0522    {
0523       case 97:
0524          return jjMoveStringLiteralDfa5_0(active1, 0x4000008000000L, active2, 0L);
0525       case 99:
0526          return jjMoveStringLiteralDfa5_0(active1, 0xa040000000L, active2, 0L);
0527       case 100:
0528          return jjMoveStringLiteralDfa5_0(active1, 0x80000000000L, active2, 0L);
0529       case 101:
0530          if ((active1 & 0x2000000000000L!= 0L)
0531             return jjStartNfaWithStates_0(411329);
0532          else if ((active1 & 0x10000000000000L!= 0L)
0533             return jjStartNfaWithStates_0(411629);
0534          return jjMoveStringLiteralDfa5_0(active1, 0x410000000L, active2, 0L);
0535       case 103:
0536          return jjMoveStringLiteralDfa5_0(active1, 0x200000000000L, active2, 0L);
0537       case 104:
0538          if ((active1 & 0x80L!= 0L)
0539             return jjStartNfaWithStates_0(47129);
0540          break;
0541       case 105:
0542          return jjMoveStringLiteralDfa5_0(active1, 0x1020000400L, active2, 0L);
0543       case 107:
0544          if ((active1 & 0x20L!= 0L)
0545             return jjStartNfaWithStates_0(46929);
0546          break;
0547       case 108:
0548          return jjMoveStringLiteralDfa5_0(active1, 0x10000004000L, active2, 0x40L);
0549       case 110:
0550          if ((active1 & 0x100000000000L!= 0L)
0551             return jjStartNfaWithStates_0(410829);
0552          return jjMoveStringLiteralDfa5_0(active1, 0x900000L, active2, 0L);
0553       case 111:
0554          return jjMoveStringLiteralDfa5_0(active1, 0x800000000L, active2, 0L);
0555       case 114:
0556          return jjMoveStringLiteralDfa5_0(active1, 0x100020000L, active2, 0L);
0557       case 115:
0558          if ((active1 & 0x4000000000L!= 0L)
0559             return jjStartNfaWithStates_0(410229);
0560          return jjMoveStringLiteralDfa5_0(active1, 0x80000000L, active2, 0L);
0561       case 116:
0562          if ((active1 & 0x200L!= 0L)
0563             return jjStartNfaWithStates_0(47329);
0564          else if ((active1 & 0x40000L!= 0L)
0565             return jjStartNfaWithStates_0(48229);
0566          else if ((active1 & 0x200000000L!= 0L)
0567             return jjStartNfaWithStates_0(49729);
0568          return jjMoveStringLiteralDfa5_0(active1, 0x1000000001000L, active2, 0L);
0569       case 117:
0570          return jjMoveStringLiteralDfa5_0(active1, 0x400000000800L, active2, 0L);
0571       case 119:
0572          if ((active1 & 0x20000000000000L!= 0L)
0573             return jjStartNfaWithStates_0(411729);
0574          break;
0575       default :
0576          break;
0577    }
0578    return jjStartNfa_0(30L, active1, active2);
0579 }
0580 private int jjMoveStringLiteralDfa5_0(long old1, long active1, long old2, long active2)
0581 {
0582    if (((active1 &= old1(active2 &= old2)) == 0L)
0583       return jjStartNfa_0(30L, old1, old2);
0584    try curChar = input_stream.readChar()}
0585    catch(java.io.IOException e) {
0586       jjStopStringLiteralDfa_0(40L, active1, active2);
0587       return 5;
0588    }
0589    switch(curChar)
0590    {
0591       case 97:
0592          return jjMoveStringLiteralDfa6_0(active1, 0x410000000000L, active2, 0L);
0593       case 99:
0594          if ((active1 & 0x20000000L!= 0L)
0595             return jjStartNfaWithStates_0(59329);
0596          else if ((active1 & 0x1000000000L!= 0L)
0597             return jjStartNfaWithStates_0(510029);
0598          return jjMoveStringLiteralDfa6_0(active1, 0x10000000L, active2, 0L);
0599       case 100:
0600          if ((active1 & 0x100000L!= 0L)
0601             return jjStartNfaWithStates_0(58429);
0602          else if ((active1 & 0x400000000L!= 0L)
0603             return jjStartNfaWithStates_0(59829);
0604          break;
0605       case 101:
0606          if ((active1 & 0x1000L!= 0L)
0607             return jjStartNfaWithStates_0(57629);
0608          else if ((active1 & 0x4000L!= 0L)
0609             return jjStartNfaWithStates_0(57829);
0610          else if ((active1 & 0x800000L!= 0L)
0611             return jjStartNfaWithStates_0(58729);
0612          return jjMoveStringLiteralDfa6_0(active1, 0x80000000000L, active2, 0L);
0613       case 102:
0614          if ((active1 & 0x800000000L!= 0L)
0615             return jjStartNfaWithStates_0(59929);
0616          break;
0617       case 104:
0618          if ((active1 & 0x8000000000L!= 0L)
0619             return jjStartNfaWithStates_0(510329);
0620          break;
0621       case 105:
0622          return jjMoveStringLiteralDfa6_0(active1, 0x1000000000000L, active2, 0L);
0623       case 108:
0624          return jjMoveStringLiteralDfa6_0(active1, 0x40000800L, active2, 0x40L);
0625       case 110:
0626          if ((active1 & 0x20000L!= 0L)
0627             return jjStartNfaWithStates_0(58129);
0628          else if ((active1 & 0x100000000L!= 0L)
0629             return jjStartNfaWithStates_0(59629);
0630          return jjMoveStringLiteralDfa6_0(active1, 0x200000000400L, active2, 0L);
0631       case 116:
0632          if ((active1 & 0x2000000000L!= 0L)
0633             return jjStartNfaWithStates_0(510129);
0634          return jjMoveStringLiteralDfa6_0(active1, 0x4000088000000L, active2, 0L);
0635       default :
0636          break;
0637    }
0638    return jjStartNfa_0(40L, active1, active2);
0639 }
0640 private int jjMoveStringLiteralDfa6_0(long old1, long active1, long old2, long active2)
0641 {
0642    if (((active1 &= old1(active2 &= old2)) == 0L)
0643       return jjStartNfa_0(40L, old1, old2);
0644    try curChar = input_stream.readChar()}
0645    catch(java.io.IOException e) {
0646       jjStopStringLiteralDfa_0(50L, active1, active2);
0647       return 6;
0648    }
0649    switch(curChar)
0650    {
0651       case 97:
0652          return jjMoveStringLiteralDfa7_0(active1, 0x40000000L, active2, 0L);
0653       case 101:
0654          if ((active1 & 0x8000000L!= 0L)
0655             return jjStartNfaWithStates_0(69129);
0656          return jjMoveStringLiteralDfa7_0(active1, 0x200080000000L, active2, 0L);
0657       case 102:
0658          if ((active1 & 0x80000000000L!= 0L)
0659             return jjStartNfaWithStates_0(610729);
0660          break;
0661       case 108:
0662          if ((active1 & 0x400000000000L!= 0L)
0663             return jjStartNfaWithStates_0(611029);
0664          return jjMoveStringLiteralDfa7_0(active1, 0x1000000000000L, active2, 0L);
0665       case 111:
0666          return jjMoveStringLiteralDfa7_0(active1, 0x4000000000000L, active2, 0L);
0667       case 116:
0668          if ((active1 & 0x800L!= 0L)
0669             return jjStartNfaWithStates_0(67529);
0670          return jjMoveStringLiteralDfa7_0(active1, 0x10010000000L, active2, 0L);
0671       case 117:
0672          return jjMoveStringLiteralDfa7_0(active1, 0x400L, active2, 0L);
0673       case 121:
0674          if ((active2 & 0x40L!= 0L)
0675             return jjStartNfaWithStates_0(613429);
0676          break;
0677       default :
0678          break;
0679    }
0680    return jjStartNfa_0(50L, active1, active2);
0681 }
0682 private int jjMoveStringLiteralDfa7_0(long old1, long active1, long old2, long active2)
0683 {
0684    if (((active1 &= old1(active2 &= old2)) == 0L)
0685       return jjStartNfa_0(50L, old1, old2);
0686    try curChar = input_stream.readChar()}
0687    catch(java.io.IOException e) {
0688       jjStopStringLiteralDfa_0(60L, active1, 0L);
0689       return 7;
0690    }
0691    switch(curChar)
0692    {
0693       case 100:
0694          if ((active1 & 0x200000000000L!= 0L)
0695             return jjStartNfaWithStates_0(710929);
0696          break;
0697       case 101:
0698          if ((active1 & 0x400L!= 0L)
0699             return jjStartNfaWithStates_0(77429);
0700          else if ((active1 & 0x10000000000L!= 0L)
0701             return jjStartNfaWithStates_0(710429);
0702          else if ((active1 & 0x1000000000000L!= 0L)
0703             return jjStartNfaWithStates_0(711229);
0704          return jjMoveStringLiteralDfa8_0(active1, 0x10000000L);
0705       case 114:
0706          if ((active1 & 0x80000000L!= 0L)
0707             return jjStartNfaWithStates_0(79529);
0708          else if ((active1 & 0x4000000000000L!= 0L)
0709             return jjStartNfaWithStates_0(711429);
0710          return jjMoveStringLiteralDfa8_0(active1, 0x40000000L);
0711       default :
0712          break;
0713    }
0714    return jjStartNfa_0(60L, active1, 0L);
0715 }
0716 private int jjMoveStringLiteralDfa8_0(long old1, long active1)
0717 {
0718    if (((active1 &= old1)) == 0L)
0719       return jjStartNfa_0(60L, old1, 0L);
0720    try curChar = input_stream.readChar()}
0721    catch(java.io.IOException e) {
0722       jjStopStringLiteralDfa_0(70L, active1, 0L);
0723       return 8;
0724    }
0725    switch(curChar)
0726    {
0727       case 100:
0728          if ((active1 & 0x10000000L!= 0L)
0729             return jjStartNfaWithStates_0(89229);
0730          break;
0731       case 101:
0732          return jjMoveStringLiteralDfa9_0(active1, 0x40000000L);
0733       default :
0734          break;
0735    }
0736    return jjStartNfa_0(70L, active1, 0L);
0737 }
0738 private int jjMoveStringLiteralDfa9_0(long old1, long active1)
0739 {
0740    if (((active1 &= old1)) == 0L)
0741       return jjStartNfa_0(70L, old1, 0L);
0742    try curChar = input_stream.readChar()}
0743    catch(java.io.IOException e) {
0744       jjStopStringLiteralDfa_0(80L, active1, 0L);
0745       return 9;
0746    }
0747    switch(curChar)
0748    {
0749       case 100:
0750          if ((active1 & 0x40000000L!= 0L)
0751             return jjStartNfaWithStates_0(99429);
0752          break;
0753       default :
0754          break;
0755    }
0756    return jjStartNfa_0(80L, active1, 0L);
0757 }
0758 private int jjStartNfaWithStates_0(int pos, int kind, int state)
0759 {
0760    jjmatchedKind = kind;
0761    jjmatchedPos = pos;
0762    try curChar = input_stream.readChar()}
0763    catch(java.io.IOException e) { return pos + 1}
0764    return jjMoveNfa_0(state, pos + 1);
0765 }
0766 static final long[] jjbitVec0 = {
0767    0x0L0x0L0xffffffffffffffffL0xffffffffffffffffL
0768 };
0769 private int jjMoveNfa_0(int startState, int curPos)
0770 {
0771    int startsAt = 0;
0772    jjnewStateCnt = 78;
0773    int i = 1;
0774    jjstateSet[0= startState;
0775    int kind = 0x7fffffff;
0776    for (;;)
0777    {
0778       if (++jjround == 0x7fffffff)
0779          ReInitRounds();
0780       if (curChar < 64)
0781       {
0782          long l = 1L << curChar;
0783          do
0784          {
0785             switch(jjstateSet[--i])
0786             {
0787                case 28:
0788                   if ((0x3ff000000000000L & l!= 0L)
0789                      jjCheckNAddStates(05);
0790                   else if (curChar == 36)
0791                   {
0792                      if (kind > 135)
0793                         kind = 135;
0794                      jjCheckNAdd(29);
0795                   }
0796                   else if (curChar == 34)
0797                      jjCheckNAddStates(68);
0798                   else if (curChar == 39)
0799                      jjCheckNAddTwoStates(79);
0800                   else if (curChar == 46)
0801                      jjCheckNAdd(1);
0802                   if ((0x3fe000000000000L & l!= 0L)
0803                   {
0804                      if (kind > 122)
0805                         kind = 122;
0806                      jjCheckNAddStates(916);
0807                   }
0808                   else if (curChar == 48)
0809                      jjAddStates(1720);
0810                   if (curChar == 48)
0811                   {
0812                      if (kind > 118)
0813                         kind = 118;
0814                      jjCheckNAddStates(2128);
0815                   }
0816                   break;
0817                case 0:
0818                   if (curChar == 46)
0819                      jjCheckNAdd(1);
0820                   break;
0821                case 1:
0822                   if ((0x3ff000000000000L & l== 0L)
0823                      break;
0824                   if (kind > 130)
0825                      kind = 130;
0826                   jjCheckNAddStates(2931);
0827                   break;
0828                case 3:
0829                   if ((0x280000000000L & l!= 0L)
0830                      jjCheckNAdd(4);
0831                   break;
0832                case 4:
0833                   if ((0x3ff000000000000L & l== 0L)
0834                      break;
0835                   if (kind > 130)
0836                      kind = 130;
0837                   jjCheckNAddTwoStates(45);
0838                   break;
0839                case 6:
0840                   if (curChar == 39)
0841                      jjCheckNAddTwoStates(79);
0842                   break;
0843                case 7:
0844                   if ((0xffffff7fffffdbffL & l!= 0L)
0845                      jjCheckNAddTwoStates(78);
0846                   break;
0847                case 8:
0848                   if (curChar == 39 && kind > 132)
0849                      kind = 132;
0850                   break;
0851                case 10:
0852                   if ((0x8000008400000000L & l!= 0L)
0853                      jjCheckNAdd(8);
0854                   break;
0855                case 11:
0856                   if (curChar == 48)
0857                      jjCheckNAddTwoStates(128);
0858                   break;
0859                case 12:
0860                   if ((0xff000000000000L & l!= 0L)
0861                      jjCheckNAddTwoStates(128);
0862                   break;
0863                case 13:
0864                   if ((0x3fe000000000000L & l!= 0L)
0865                      jjCheckNAddTwoStates(148);
0866                   break;
0867                case 14:
0868                   if ((0x3ff000000000000L & l!= 0L)
0869                      jjCheckNAddTwoStates(148);
0870                   break;
0871                case 16:
0872                   if ((0x3ff000000000000L & l!= 0L)
0873                      jjCheckNAddTwoStates(168);
0874                   break;
0875                case 17:
0876                   if (curChar == 34)
0877                      jjCheckNAddStates(68);
0878                   break;
0879                case 18:
0880                   if ((0xfffffffbffffdbffL & l!= 0L)
0881                      jjCheckNAddStates(68);
0882                   break;
0883                case 20:
0884                   if ((0x8000008400000400L & l!= 0L)
0885                      jjCheckNAddStates(68);
0886                   break;
0887                case 21:
0888                   if (curChar == 34 && kind > 133)
0889                      kind = 133;
0890                   break;
0891                case 22:
0892                   if (curChar == 48)
0893                      jjCheckNAddStates(3235);
0894                   break;
0895                case 23:
0896                   if ((0xff000000000000L & l!= 0L)
0897                      jjCheckNAddStates(3235);
0898                   break;
0899                case 24:
0900                   if ((0x3fe000000000000L & l!= 0L)
0901                      jjCheckNAddStates(3639);
0902                   break;
0903                case 25:
0904                   if ((0x3ff000000000000L & l!= 0L)
0905                      jjCheckNAddStates(3639);
0906                   break;
0907                case 27:
0908                   if ((0x3ff000000000000L & l!= 0L)
0909                      jjCheckNAddStates(4043);
0910                   break;
0911                case 29:
0912                   if ((0x3ff001000000000L & l== 0L)
0913                      break;
0914                   if (kind > 135)
0915                      kind = 135;
0916                   jjCheckNAdd(29);
0917                   break;
0918                case 30:
0919                   if (curChar != 48)
0920                      break;
0921                   if (kind > 118)
0922                      kind = 118;
0923                   jjCheckNAddStates(2128);
0924                   break;
0925                case 31:
0926                   if ((0xff000000000000L & l== 0L)
0927                      break;
0928                   if (kind > 118)
0929                      kind = 118;
0930                   jjCheckNAdd(31);
0931                   break;
0932                case 32:
0933                   if ((0xff000000000000L & l!= 0L)
0934                      jjCheckNAddTwoStates(3233);
0935                   break;
0936                case 34:
0937                   if ((0xff000000000000L & l!= 0L)
0938                      jjCheckNAddTwoStates(3435);
0939                   break;
0940                case 36:
0941                   if ((0xff000000000000L & l!= 0L)
0942                      jjCheckNAddStates(4446);
0943                   break;
0944                case 41:
0945                   if ((0x3fe000000000000L & l== 0L)
0946                      break;
0947                   if (kind > 122)
0948                      kind = 122;
0949                   jjCheckNAddStates(916);
0950                   break;
0951                case 42:
0952                   if ((0x3ff000000000000L & l== 0L)
0953                      break;
0954                   if (kind > 122)
0955                      kind = 122;
0956                   jjCheckNAdd(42);
0957                   break;
0958                case 43:
0959                   if ((0x3ff000000000000L & l!= 0L)
0960                      jjCheckNAddTwoStates(4344);
0961                   break;
0962                case 45:
0963                   if ((0x3ff000000000000L & l!= 0L)
0964                      jjCheckNAddTwoStates(4546);
0965                   break;
0966                case 47:
0967                   if ((0x3ff000000000000L & l!= 0L)
0968                      jjCheckNAddStates(4749);
0969                   break;
0970                case 52:
0971                   if (curChar == 48)
0972                      jjAddStates(1720);
0973                   break;
0974                case 54:
0975                   if ((0x3ff000000000000L & l== 0L)
0976                      break;
0977                   if (kind > 126)
0978                      kind = 126;
0979                   jjstateSet[jjnewStateCnt++54;
0980                   break;
0981                case 56:
0982                   if ((0x3ff000000000000L & l== 0L)
0983                      break;
0984                   if (kind > 127)
0985                      kind = 127;
0986                   jjAddStates(5051);
0987                   break;
0988                case 59:
0989                   if ((0x3ff000000000000L & l!= 0L)
0990                      jjAddStates(5253);
0991                   break;
0992                case 62:
0993                   if ((0x3ff000000000000L & l!= 0L)
0994                      jjAddStates(5456);
0995                   break;
0996                case 67:
0997                   if ((0x3ff000000000000L & l!= 0L)
0998                      jjCheckNAddStates(05);
0999                   break;
1000                case 68:
1001                   if ((0x3ff000000000000L & l!= 0L)
1002                      jjCheckNAddTwoStates(6869);
1003                   break;
1004                case 69:
1005                   if (curChar != 46)
1006                      break;
1007                   if (kind > 130)
1008                      kind = 130;
1009                   jjCheckNAddStates(5759);
1010                   break;
1011                case 70:
1012                   if ((0x3ff000000000000L & l== 0L)
1013                      break;
1014                   if (kind > 130)
1015                      kind = 130;
1016                   jjCheckNAddStates(5759);
1017                   break;
1018                case 71:
1019                   if ((0x3ff000000000000L & l!= 0L)
1020                      jjCheckNAddTwoStates(710);
1021                   break;
1022                case 72:
1023                   if ((0x3ff000000000000L & l!= 0L)
1024                      jjCheckNAddTwoStates(7273);
1025                   break;
1026                case 74:
1027                   if ((0x280000000000L & l!= 0L)
1028                      jjCheckNAdd(75);
1029                   break;
1030                case 75:
1031                   if ((0x3ff000000000000L & l== 0L)
1032                      break;
1033                   if (kind > 131)
1034                      kind = 131;
1035                   jjCheckNAddTwoStates(7576);
1036                   break;
1037                default break;
1038             }
1039          while(i != startsAt);
1040       }
1041       else if (curChar < 128)
1042       {
1043          long l = 1L << (curChar & 077);
1044          do
1045          {
1046             switch(jjstateSet[--i])
1047             {
1048                case 28:
1049                   if ((0x7fffffe87fffffeL & l!= 0L)
1050                   {
1051                      if (kind > 135)
1052                         kind = 135;
1053                      jjCheckNAdd(29);
1054                   }
1055                   if (curChar == 76)
1056                      jjAddStates(6061);
1057                   break;
1058                case 2:
1059                   if ((0x2000000020L & l!= 0L)
1060                      jjAddStates(6263);
1061                   break;
1062                case 5:
1063                   if ((0x104000001040L & l!= 0L && kind > 130)
1064                      kind = 130;
1065                   break;
1066                case 7:
1067                   if ((0xffffffffefffffffL & l!= 0L)
1068                      jjCheckNAddTwoStates(78);
1069                   break;
1070                case 9:
1071                   if (curChar == 92)
1072                      jjAddStates(6467);
1073                   break;
1074                case 10:
1075                   if ((0x54404610000000L & l!= 0L)
1076                      jjCheckNAdd(8);
1077                   break;
1078                case 15:
1079                   if ((0x100000001000000L & l!= 0L)
1080                      jjCheckNAdd(16);
1081                   break;
1082                case 16:
1083                   if ((0x7e0000007eL & l!= 0L)
1084                      jjCheckNAddTwoStates(168);
1085                   break;
1086                case 18:
1087                   if ((0xffffffffefffffffL & l!= 0L)
1088                      jjCheckNAddStates(68);
1089                   break;
1090                case 19:
1091                   if (curChar == 92)
1092                      jjAddStates(6871);
1093                   break;
1094                case 20:
1095                   if ((0x54404610000000L & l!= 0L)
1096                      jjCheckNAddStates(68);
1097                   break;
1098                case 26:
1099                   if ((0x100000001000000L & l!= 0L)
1100                      jjCheckNAdd(27);
1101                   break;
1102                case 27:
1103                   if ((0x7e0000007eL & l!= 0L)
1104                      jjCheckNAddStates(4043);
1105                   break;
1106                case 29:
1107                   if ((0x7fffffe87fffffeL & l== 0L)
1108                      break;
1109                   if (kind > 135)
1110                      kind = 135;
1111                   jjCheckNAdd(29);
1112                   break;
1113                case 33:
1114                   if ((0x100000001000L & l!= 0L && kind > 119)
1115                      kind = 119;
1116                   break;
1117                case 35:
1118                   if ((0x20000000200000L & l!= 0L && kind > 120)
1119                      kind = 120;
1120                   break;
1121                case 37:
1122                   if ((0x100000001000L & l!= 0L && kind > 121)
1123                      kind = 121;
1124                   break;
1125                case 38:
1126                   if ((0x20000000200000L & l!= 0L)
1127                      jjstateSet[jjnewStateCnt++37;
1128                   break;
1129                case 39:
1130                   if ((0x20000000200000L & l!= 0L && kind > 121)
1131                      kind = 121;
1132                   break;
1133                case 40:
1134                   if ((0x100000001000L & l!= 0L)
1135                      jjstateSet[jjnewStateCnt++39;
1136                   break;
1137                case 44:
1138                   if ((0x20100000201000L & l!= 0L && kind > 123)
1139                      kind = 123;
1140                   break;
1141                case 46:
1142                   if ((0x20000000200000L & l!= 0L && kind > 124)
1143                      kind = 124;
1144                   break;
1145                case 48:
1146                   if ((0x100000001000L & l!= 0L && kind > 125)
1147                      kind = 125;
1148                   break;
1149                case 49:
1150                   if ((0x20000000200000L & l!= 0L)
1151                      jjstateSet[jjnewStateCnt++48;
1152                   break;
1153                case 50:
1154                   if ((0x20000000200000L & l!= 0L && kind > 125)
1155                      kind = 125;
1156                   break;
1157                case 51:
1158                   if ((0x100000001000L & l!= 0L)
1159                      jjstateSet[jjnewStateCnt++50;
1160                   break;
1161                case 53:
1162                   if ((0x100000001000000L & l!= 0L)
1163                      jjCheckNAdd(54);
1164                   break;
1165                case 54:
1166                   if ((0x7e0000007eL & l== 0L)
1167                      break;
1168                   if (kind > 126)
1169                      kind = 126;
1170                   jjCheckNAdd(54);
1171                   break;
1172                case 55:
1173                   if ((0x100000001000000L & l!= 0L)
1174                      jjCheckNAdd(56);
1175                   break;
1176                case 56:
1177                   if ((0x7e0000007eL & l== 0L)
1178                      break;
1179                   if (kind > 127)
1180                      kind = 127;
1181                   jjCheckNAddTwoStates(5657);
1182                   break;
1183                case 57:
1184                   if ((0x20100000201000L & l!= 0L && kind > 127)
1185                      kind = 127;
1186                   break;
1187                case 58:
1188                   if ((0x100000001000000L & l!= 0L)
1189                      jjCheckNAdd(59);
1190                   break;
1191                case 59:
1192                   if ((0x7e0000007eL & l!= 0L)
1193                      jjCheckNAddTwoStates(5960);
1194                   break;
1195                case 60:
1196                   if ((0x20000000200000L & l!= 0L && kind > 128)
1197                      kind = 128;
1198                   break;
1199                case 61:
1200                   if ((0x100000001000000L & l!= 0L)
1201                      jjCheckNAdd(62);
1202                   break;
1203                case 62:
1204                   if ((0x7e0000007eL & l!= 0L)
1205                      jjCheckNAddStates(5456);
1206                   break;
1207                case 63:
1208                   if ((0x100000001000L & l!= 0L && kind > 129)
1209                      kind = 129;
1210                   break;
1211                case 64:
1212                   if ((0x20000000200000L & l!= 0L)
1213                      jjstateSet[jjnewStateCnt++63;
1214                   break;
1215                case 65:
1216                   if ((0x20000000200000L & l!= 0L && kind > 129)
1217                      kind = 129;
1218                   break;
1219                case 66:
1220                   if ((0x100000001000L & l!= 0L)
1221                      jjstateSet[jjnewStateCnt++65;
1222                   break;
1223                case 73:
1224                   if ((0x2000000020L & l!= 0L)
1225                      jjAddStates(7273);
1226                   break;
1227                case 76:
1228                   if ((0x104000001040L & l!= 0L && kind > 131)
1229                      kind = 131;
1230                   break;
1231                case 77:
1232                   if (curChar == 76)
1233                      jjAddStates(6061);
1234                   break;
1235                default break;
1236             }
1237          while(i != startsAt);
1238       }
1239       else
1240       {
1241          int i2 = (curChar & 0xff>> 6;
1242          long l2 = 1L << (curChar & 077);
1243          do
1244          {
1245             switch(jjstateSet[--i])
1246             {
1247                case 7:
1248                   if ((jjbitVec0[i2& l2!= 0L)
1249                      jjAddStates(7475);
1250                   break;
1251                case 18:
1252                   if ((jjbitVec0[i2& l2!= 0L)
1253                      jjAddStates(68);
1254                   break;
1255                default break;
1256             }
1257          while(i != startsAt);
1258       }
1259       if (kind != 0x7fffffff)
1260       {
1261          jjmatchedKind = kind;
1262          jjmatchedPos = curPos;
1263          kind = 0x7fffffff;
1264       }
1265       ++curPos;
1266       if ((i = jjnewStateCnt== (startsAt = 78 (jjnewStateCnt = startsAt)))
1267          return curPos;
1268       try curChar = input_stream.readChar()}
1269       catch(java.io.IOException e) { return curPos; }
1270    }
1271 }
1272 private int jjMoveStringLiteralDfa0_1()
1273 {
1274    switch(curChar)
1275    {
1276       case 10:
1277          return jjStopAtPos(09);
1278       default :
1279          return 1;
1280    }
1281 }
1282 private int jjMoveStringLiteralDfa0_4()
1283 {
1284    switch(curChar)
1285    {
1286       case 10:
1287          return jjStopAtPos(014);
1288       case 47:
1289          return jjMoveStringLiteralDfa1_4(0x8000L);
1290       case 92:
1291          return jjMoveStringLiteralDfa1_4(0x30000L);
1292       default :
1293          return 1;
1294    }
1295 }
1296 private int jjMoveStringLiteralDfa1_4(long active0)
1297 {
1298    try curChar = input_stream.readChar()}
1299    catch(java.io.IOException e) {
1300       return 1;
1301    }
1302    switch(curChar)
1303    {
1304       case 10:
1305          if ((active0 & 0x10000L!= 0L)
1306             return jjStopAtPos(116);
1307          break;
1308       case 13:
1309          return jjMoveStringLiteralDfa2_4(active0, 0x20000L);
1310       case 42:
1311          if ((active0 & 0x8000L!= 0L)
1312             return jjStopAtPos(115);
1313          break;
1314       default :
1315          return 2;
1316    }
1317    return 2;
1318 }
1319 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
1320 {
1321    if (((active0 &= old0)) == 0L)
1322       return 2;
1323    try curChar = input_stream.readChar()}
1324    catch(java.io.IOException e) {
1325       return 2;
1326    }
1327    switch(curChar)
1328    {
1329       case 10:
1330          if ((active0 & 0x20000L!= 0L)
1331             return jjStopAtPos(217);
1332          break;
1333       default :
1334          return 3;
1335    }
1336    return 3;
1337 }
1338 private int jjMoveStringLiteralDfa0_3()
1339 {
1340    switch(curChar)
1341    {
1342       case 42:
1343          return jjMoveStringLiteralDfa1_3(0x2000L);
1344       default :
1345          return 1;
1346    }
1347 }
1348 private int jjMoveStringLiteralDfa1_3(long active0)
1349 {
1350    try curChar = input_stream.readChar()}
1351    catch(java.io.IOException e) {
1352       return 1;
1353    }
1354    switch(curChar)
1355    {
1356       case 47:
1357          if ((active0 & 0x2000L!= 0L)
1358             return jjStopAtPos(113);
1359          break;
1360       default :
1361          return 2;
1362    }
1363    return 2;
1364 }
1365 private int jjMoveStringLiteralDfa0_2()
1366 {
1367    switch(curChar)
1368    {
1369       case 42:
1370          return jjMoveStringLiteralDfa1_2(0x800L);
1371       default :
1372          return 1;
1373    }
1374 }
1375 private int jjMoveStringLiteralDfa1_2(long active0)
1376 {
1377    try curChar = input_stream.readChar()}
1378    catch(java.io.IOException e) {
1379       return 1;
1380    }
1381    switch(curChar)
1382    {
1383       case 47:
1384          if ((active0 & 0x800L!= 0L)
1385             return jjStopAtPos(111);
1386          break;
1387       default :
1388          return 2;
1389    }
1390    return 2;
1391 }
1392 static final int[] jjnextStates = {
1393    6869710727318192142434445464749
1394    51535558613132333435363840125
1395    18192321181925211819272136384047
1396    495156575960626466702561734
1397    1011131520222426747578
1398 };
1399 
1400 /** Token literal values. */
1401 public static final String[] jjstrLiteralImages = {
1402 "", null, null, null, null, null, null, null, null, null, null, null, null, 
1403 null, null, null, null, null, null, "\173""\175""\133""\135""\50""\51"
1404 "\72\72""\72""\73""\54""\77""\56\56\56""\75""\52\75""\57\75""\45\75"
1405 "\53\75""\55\75""\74\74\75""\76\76\75""\46\75""\136\75""\174\75"
1406 "\174\174""\46\46""\174""\136""\46""\75\75""\41\75""\74""\76""\74\75"
1407 "\76\75""\74\74""\76\76""\53""\55""\52""\57""\45""\53\53""\55\55"
1408 "\176""\41""\56""\55\76""\56\52""\55\76\52""\141\165\164\157"
1409 "\142\162\145\141\153""\143\141\163\145""\143\141\164\143\150""\143\150\141\162"
1410 "\143\157\156\163\164""\143\157\156\164\151\156\165\145""\144\145\146\141\165\154\164"
1411 "\144\145\154\145\164\145""\144\157""\144\157\165\142\154\145""\145\154\163\145"
1412 "\145\156\165\155""\145\170\164\145\162\156""\146\154\157\141\164""\146\157\162"
1413 "\146\162\151\145\156\144""\147\157\164\157""\151\146""\151\156\154\151\156\145""\151\156\164"
1414 "\154\157\156\147""\156\145\167""\160\162\151\166\141\164\145"
1415 "\160\162\157\164\145\143\164\145\144""\160\165\142\154\151\143""\162\145\144\145\143\154\141\162\145\144"
1416 "\162\145\147\151\163\164\145\162""\162\145\164\165\162\156""\163\150\157\162\164"
1417 "\163\151\147\156\145\144""\163\151\172\145\157\146""\163\164\141\164\151\143"
1418 "\163\164\162\165\143\164""\143\154\141\163\163""\163\167\151\164\143\150"
1419 "\164\145\155\160\154\141\164\145""\164\150\151\163""\164\162\171""\164\171\160\145\144\145\146"
1420 "\165\156\151\157\156""\165\156\163\151\147\156\145\144""\166\151\162\164\165\141\154"
1421 "\166\157\151\144""\166\157\154\141\164\151\154\145""\167\150\151\154\145"
1422 "\157\160\145\162\141\164\157\162""\164\162\165\145""\146\141\154\163\145""\164\150\162\157\167", null, null, 
1423 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1424 "\146\151\156\141\154\154\171", null, };
1425 
1426 /** Lexer state names. */
1427 public static final String[] lexStateNames = {
1428    "DEFAULT",
1429    "IN_LINE_COMMENT",
1430    "IN_COMMENT",
1431    "IN_PREPROCESSOR_OUTPUT_COMMENT",
1432    "PREPROCESSOR_OUTPUT",
1433 };
1434 
1435 /** Lex State array. */
1436 public static final int[] jjnewLexState = {
1437    -1, -1, -1, -1, -1, -11240, -10, -1403, -1, -1, -1, -1, -1, -1, -1, -1, -1
1438    -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
1439    -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
1440    -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
1441    -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
1442    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
1443 };
1444 static final long[] jjtoToken = {
1445    0xfffffffffff80001L0xffffffffffffffffL0xffL
1446 };
1447 static final long[] jjtoSkip = {
1448    0xebfeL0x0L0x0L
1449 };
1450 static final long[] jjtoMore = {
1451    0x71400L0x0L0x0L
1452 };
1453 protected CharStream input_stream;
1454 private final int[] jjrounds = new int[78];
1455 private final int[] jjstateSet = new int[156];
1456 protected char curChar;
1457 /** Constructor. */
1458 public CppParserTokenManager(CharStream stream){
1459    input_stream = stream;
1460 }
1461 
1462 /** Constructor. */
1463 public CppParserTokenManager(CharStream stream, int lexState){
1464    this(stream);
1465    SwitchTo(lexState);
1466 }
1467 
1468 /** Reinitialise parser. */
1469 public void ReInit(CharStream stream)
1470 {
1471    jjmatchedPos = jjnewStateCnt = 0;
1472    curLexState = defaultLexState;
1473    input_stream = stream;
1474    ReInitRounds();
1475 }
1476 private void ReInitRounds()
1477 {
1478    int i;
1479    jjround = 0x80000001;
1480    for (i = 78; i-- > 0;)
1481       jjrounds[i0x80000000;
1482 }
1483 
1484 /** Reinitialise parser. */
1485 public void ReInit(CharStream stream, int lexState)
1486 {
1487    ReInit(stream);
1488    SwitchTo(lexState);
1489 }
1490 
1491 /** Switch to specified lex state. */
1492 public void SwitchTo(int lexState)
1493 {
1494    if (lexState >= || lexState < 0)
1495       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1496    else
1497       curLexState = lexState;
1498 }
1499 
1500 protected Token jjFillToken()
1501 {
1502    final Token t;
1503    final String curTokenImage;
1504    final int beginLine;
1505    final int endLine;
1506    final int beginColumn;
1507    final int endColumn;
1508    String im = jjstrLiteralImages[jjmatchedKind];
1509    curTokenImage = (im == null? input_stream.GetImage() : im;
1510    beginLine = input_stream.getBeginLine();
1511    beginColumn = input_stream.getBeginColumn();
1512    endLine = input_stream.getEndLine();
1513    endColumn = input_stream.getEndColumn();
1514    t = Token.newToken(jjmatchedKind, curTokenImage);
1515 
1516    t.beginLine = beginLine;
1517    t.endLine = endLine;
1518    t.beginColumn = beginColumn;
1519    t.endColumn = endColumn;
1520 
1521    return t;
1522 }
1523 
1524 int curLexState = 0;
1525 int defaultLexState = 0;
1526 int jjnewStateCnt;
1527 int jjround;
1528 int jjmatchedPos;
1529 int jjmatchedKind;
1530 
1531 /** Get the next Token. */
1532 public Token getNextToken() 
1533 {
1534   Token matchedToken;
1535   int curPos = 0;
1536 
1537   EOFLoop :
1538   for (;;)
1539   {
1540    try
1541    {
1542       curChar = input_stream.BeginToken();
1543    }
1544    catch(java.io.IOException e)
1545    {
1546       jjmatchedKind = 0;
1547       matchedToken = jjFillToken();
1548       return matchedToken;
1549    }
1550 
1551    for (;;)
1552    {
1553      switch(curLexState)
1554      {
1555        case 0:
1556          try input_stream.backup(0);
1557             while (curChar <= 32 && (0x100001600L (1L << curChar)) != 0L)
1558                curChar = input_stream.BeginToken();
1559          }
1560          catch (java.io.IOException e1) { continue EOFLoop; }
1561          jjmatchedKind = 0x7fffffff;
1562          jjmatchedPos = 0;
1563          curPos = jjMoveStringLiteralDfa0_0();
1564          break;
1565        case 1:
1566          jjmatchedKind = 0x7fffffff;
1567          jjmatchedPos = 0;
1568          curPos = jjMoveStringLiteralDfa0_1();
1569          if (jjmatchedPos == && jjmatchedKind > 10)
1570          {
1571             jjmatchedKind = 10;
1572          }
1573          break;
1574        case 2:
1575          jjmatchedKind = 0x7fffffff;
1576          jjmatchedPos = 0;
1577          curPos = jjMoveStringLiteralDfa0_2();
1578          if (jjmatchedPos == && jjmatchedKind > 12)
1579          {
1580             jjmatchedKind = 12;
1581          }
1582          break;
1583        case 3:
1584          jjmatchedKind = 0x7fffffff;
1585          jjmatchedPos = 0;
1586          curPos = jjMoveStringLiteralDfa0_3();
1587          if (jjmatchedPos == && jjmatchedKind > 12)
1588          {
1589             jjmatchedKind = 12;
1590          }
1591          break;
1592        case 4:
1593          jjmatchedKind = 0x7fffffff;
1594          jjmatchedPos = 0;
1595          curPos = jjMoveStringLiteralDfa0_4();
1596          if (jjmatchedPos == && jjmatchedKind > 18)
1597          {
1598             jjmatchedKind = 18;
1599          }
1600          break;
1601      }
1602      if (jjmatchedKind != 0x7fffffff)
1603      {
1604         if (jjmatchedPos + < curPos)
1605            input_stream.backup(curPos - jjmatchedPos - 1);
1606         if ((jjtoToken[jjmatchedKind >> 6(1L << (jjmatchedKind & 077))) != 0L)
1607         {
1608            matchedToken = jjFillToken();
1609        if (jjnewLexState[jjmatchedKind!= -1)
1610          curLexState = jjnewLexState[jjmatchedKind];
1611            return matchedToken;
1612         }
1613         else if ((jjtoSkip[jjmatchedKind >> 6(1L << (jjmatchedKind & 077))) != 0L)
1614         {
1615          if (jjnewLexState[jjmatchedKind!= -1)
1616            curLexState = jjnewLexState[jjmatchedKind];
1617            continue EOFLoop;
1618         }
1619       if (jjnewLexState[jjmatchedKind!= -1)
1620         curLexState = jjnewLexState[jjmatchedKind];
1621         curPos = 0;
1622         jjmatchedKind = 0x7fffffff;
1623         try {
1624            curChar = input_stream.readChar();
1625            continue;
1626         }
1627         catch (java.io.IOException e1) { }
1628      }
1629      int error_line = input_stream.getEndLine();
1630      int error_column = input_stream.getEndColumn();
1631      String error_after = null;
1632      boolean EOFSeen = false;
1633      try input_stream.readChar(); input_stream.backup(1)}
1634      catch (java.io.IOException e1) {
1635         EOFSeen = true;
1636         error_after = curPos <= "" : input_stream.GetImage();
1637         if (curChar == '\n' || curChar == '\r') {
1638            error_line++;
1639            error_column = 0;
1640         }
1641         else
1642            error_column++;
1643      }
1644      if (!EOFSeen) {
1645         input_stream.backup(1);
1646         error_after = curPos <= "" : input_stream.GetImage();
1647      }
1648      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1649    }
1650   }
1651 }
1652 
1653 private void jjCheckNAdd(int state)
1654 {
1655    if (jjrounds[state!= jjround)
1656    {
1657       jjstateSet[jjnewStateCnt++= state;
1658       jjrounds[state= jjround;
1659    }
1660 }
1661 private void jjAddStates(int start, int end)
1662 {
1663    do {
1664       jjstateSet[jjnewStateCnt++= jjnextStates[start];
1665    while (start++ != end);
1666 }
1667 private void jjCheckNAddTwoStates(int state1, int state2)
1668 {
1669    jjCheckNAdd(state1);
1670    jjCheckNAdd(state2);
1671 }
1672 
1673 private void jjCheckNAddStates(int start, int end)
1674 {
1675    do {
1676       jjCheckNAdd(jjnextStates[start]);
1677    while (start++ != end);
1678 }
1679 
1680 }