0001 /* Generated By:JJTree&JavaCC: Do not edit this line. JJTreeParserTokenManager.java */
0002 package com.javadoq.jjtree;
0003 
0004 /** Token Manager. */
0005 public class JJTreeParserTokenManager implements JJTreeParserConstants
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 & 0xa0000L) != 0L || (active1 & 0x202000000000000L) != 0L)
0018             return 2;
0019          if ((active1 & 0x4000000040000000L) != 0L)
0020             return 8;
0021          if ((active0 & 0xffffffffff000ffeL) != 0L || (active1 & 0x7ffL) != 0L || (active2 & 0x108L) != 0L)
0022          {
0023             jjmatchedKind = 137;
0024             return 32;
0025          }
0026          return -1;
0027       case 1:
0028          if ((active0 & 0x80000L) != 0L)
0029             return 0;
0030          if ((active0 & 0xffffdfe7ff000ffeL) != 0L || (active1 & 0x7ffL) != 0L || (active2 & 0x108L) != 0L)
0031          {
0032             if (jjmatchedPos != 1)
0033             {
0034                jjmatchedKind = 137;
0035                jjmatchedPos = 1;
0036             }
0037             return 32;
0038          }
0039          if ((active0 & 0x201800000000L) != 0L)
0040             return 32;
0041          return -1;
0042       case 2:
0043          if ((active0 & 0xffd9d7f7ff0007feL) != 0L || (active1 & 0x77fL) != 0L || (active2 & 0x108L) != 0L)
0044          {
0045             if (jjmatchedPos != 2)
0046             {
0047                jjmatchedKind = 137;
0048                jjmatchedPos = 2;
0049             }
0050             return 32;
0051          }
0052          if ((active0 & 0x26080000000800L) != 0L || (active1 & 0x80L) != 0L)
0053             return 32;
0054          return -1;
0055       case 3:
0056          if ((active0 & 0xff95c7d7a70004feL) != 0L || (active1 & 0x63bL) != 0L || (active2 & 0x100L) != 0L)
0057          {
0058             jjmatchedKind = 137;
0059             jjmatchedPos = 3;
0060             return 32;
0061          }
0062          if ((active0 & 0x48102058000300L) != 0L || (active1 & 0x144L) != 0L || (active2 & 0x8L) != 0L)
0063             return 32;
0064          return -1;
0065       case 4:
0066          if ((active0 & 0x6f95c056030000beL) != 0L || (active1 & 0x223L) != 0L || (active2 & 0x100L) != 0L)
0067          {
0068             if (jjmatchedPos != 4)
0069             {
0070                jjmatchedKind = 137;
0071                jjmatchedPos = 4;
0072             }
0073             return 32;
0074          }
0075          if ((active0 & 0x90000781a4000440L) != 0L || (active1 & 0x418L) != 0L)
0076             return 32;
0077          return -1;
0078       case 5:
0079          if ((active0 & 0x2c10801000000000L) != 0L || (active1 & 0x11L) != 0L || (active2 & 0x100L) != 0L)
0080             return 32;
0081          if ((active0 & 0x43854246030004beL) != 0L || (active1 & 0x222L) != 0L)
0082          {
0083             jjmatchedKind = 137;
0084             jjmatchedPos = 5;
0085             return 32;
0086          }
0087          return -1;
0088       case 6:
0089          if ((active0 & 0x42054002010004beL) != 0L || (active1 & 0x222L) != 0L)
0090          {
0091             jjmatchedKind = 137;
0092             jjmatchedPos = 6;
0093             return 32;
0094          }
0095          if ((active0 & 0x180024402000000L) != 0L)
0096             return 32;
0097          return -1;
0098       case 7:
0099          if ((active0 & 0x20540000000049eL) != 0L || (active1 & 0x22L) != 0L)
0100          {
0101             jjmatchedKind = 137;
0102             jjmatchedPos = 7;
0103             return 32;
0104          }
0105          if ((active0 & 0x4000000201000020L) != 0L || (active1 & 0x200L) != 0L)
0106             return 32;
0107          return -1;
0108       case 8:
0109          if ((active0 & 0x140000000049cL) != 0L || (active1 & 0x2L) != 0L)
0110          {
0111             jjmatchedKind = 137;
0112             jjmatchedPos = 8;
0113             return 32;
0114          }
0115          if ((active0 & 0x204000000000002L) != 0L || (active1 & 0x20L) != 0L)
0116             return 32;
0117          return -1;
0118       case 9:
0119          if ((active0 & 0x48cL) != 0L || (active1 & 0x2L) != 0L)
0120          {
0121             jjmatchedKind = 137;
0122             jjmatchedPos = 9;
0123             return 32;
0124          }
0125          if ((active0 & 0x1400000000010L) != 0L)
0126             return 32;
0127          return -1;
0128       case 10:
0129          if ((active0 & 0x488L) != 0L || (active1 & 0x2L) != 0L)
0130          {
0131             jjmatchedKind = 137;
0132             jjmatchedPos = 10;
0133             return 32;
0134          }
0135          if ((active0 & 0x4L) != 0L)
0136             return 32;
0137          return -1;
0138       case 11:
0139          if ((active0 & 0x480L) != 0L)
0140          {
0141             jjmatchedKind = 137;
0142             jjmatchedPos = 11;
0143             return 32;
0144          }
0145          if ((active0 & 0x8L) != 0L || (active1 & 0x2L) != 0L)
0146             return 32;
0147          return -1;
0148       case 12:
0149          if ((active0 & 0x400L) != 0L)
0150          {
0151             jjmatchedKind = 137;
0152             jjmatchedPos = 12;
0153             return 32;
0154          }
0155          if ((active0 & 0x80L) != 0L)
0156             return 32;
0157          return -1;
0158       case 13:
0159          if ((active0 & 0x400L) != 0L)
0160          {
0161             jjmatchedKind = 137;
0162             jjmatchedPos = 13;
0163             return 32;
0164          }
0165          return -1;
0166       default :
0167          return -1;
0168    }
0169 }
0170 private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
0171 {
0172    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
0173 }
0174 private int jjStopAtPos(int pos, int kind)
0175 {
0176    jjmatchedKind = kind;
0177    jjmatchedPos = pos;
0178    return pos + 1;
0179 }
0180 private int jjMoveStringLiteralDfa0_0()
0181 {
0182    switch(curChar)
0183    {
0184       case 9:
0185          return jjStopAtPos(0, 13);
0186       case 10:
0187          return jjStopAtPos(0, 14);
0188       case 12:
0189          return jjStopAtPos(0, 16);
0190       case 13:
0191          return jjStopAtPos(0, 15);
0192       case 32:
0193          return jjStopAtPos(0, 12);
0194       case 33:
0195          jjmatchedKind = 98;
0196          return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000L, 0x0L);
0197       case 35:
0198          return jjStopAtPos(0, 130);
0199       case 37:
0200          jjmatchedKind = 117;
0201          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000000L, 0x0L);
0202       case 38:
0203          jjmatchedKind = 114;
0204          return jjMoveStringLiteralDfa1_0(0x0L, 0x400080000000000L, 0x0L);
0205       case 40:
0206          return jjStopAtPos(0, 86);
0207       case 41:
0208          return jjStopAtPos(0, 87);
0209       case 42:
0210          jjmatchedKind = 112;
0211          return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L, 0x0L);
0212       case 43:
0213          jjmatchedKind = 110;
0214          return jjMoveStringLiteralDfa1_0(0x0L, 0x40100000000000L, 0x0L);
0215       case 44:
0216          return jjStopAtPos(0, 93);
0217       case 45:
0218          jjmatchedKind = 111;
0219          return jjMoveStringLiteralDfa1_0(0x0L, 0x80200000000000L, 0x0L);
0220       case 46:
0221          jjmatchedKind = 94;
0222          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000000L, 0x0L);
0223       case 47:
0224          jjmatchedKind = 113;
0225          return jjMoveStringLiteralDfa1_0(0xa0000L, 0x200000000000000L, 0x0L);
0226       case 58:
0227          return jjStopAtPos(0, 101);
0228       case 59:
0229          return jjStopAtPos(0, 92);
0230       case 60:
0231          jjmatchedKind = 97;
0232          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000L, 0x90L);
0233       case 61:
0234          jjmatchedKind = 96;
0235          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000L, 0x0L);
0236       case 62:
0237          jjmatchedKind = 129;
0238          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000010000000000L, 0x61L);
0239       case 63:
0240          return jjStopAtPos(0, 100);
0241       case 64:
0242          return jjStopAtPos(0, 95);
0243       case 69:
0244          return jjMoveStringLiteralDfa1_0(0x800L, 0x0L, 0x0L);
0245       case 73:
0246          return jjMoveStringLiteralDfa1_0(0x4L, 0x0L, 0x0L);
0247       case 74:
0248          return jjMoveStringLiteralDfa1_0(0x20L, 0x0L, 0x0L);
0249       case 76:
0250          return jjMoveStringLiteralDfa1_0(0x2L, 0x0L, 0x0L);
0251       case 77:
0252          return jjMoveStringLiteralDfa1_0(0x100L, 0x0L, 0x0L);
0253       case 80:
0254          return jjMoveStringLiteralDfa1_0(0x18L, 0x0L, 0x0L);
0255       case 83:
0256          return jjMoveStringLiteralDfa1_0(0x280L, 0x0L, 0x0L);
0257       case 84:
0258          return jjMoveStringLiteralDfa1_0(0x440L, 0x0L, 0x0L);
0259       case 91:
0260          return jjStopAtPos(0, 90);
0261       case 93:
0262          return jjStopAtPos(0, 91);
0263       case 94:
0264          jjmatchedKind = 116;
0265          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L, 0x0L);
0266       case 97:
0267          return jjMoveStringLiteralDfa1_0(0x1000000L, 0x0L, 0x100L);
0268       case 98:
0269          return jjMoveStringLiteralDfa1_0(0xe000000L, 0x0L, 0x0L);
0270       case 99:
0271          return jjMoveStringLiteralDfa1_0(0x3f0000000L, 0x0L, 0x0L);
0272       case 100:
0273          return jjMoveStringLiteralDfa1_0(0x1c00000000L, 0x0L, 0x0L);
0274       case 101:
0275          return jjMoveStringLiteralDfa1_0(0x6000000000L, 0x0L, 0x8L);
0276       case 102:
0277          return jjMoveStringLiteralDfa1_0(0xf8000000000L, 0x0L, 0x0L);
0278       case 103:
0279          return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L, 0x0L);
0280       case 105:
0281          return jjMoveStringLiteralDfa1_0(0x7e00000000000L, 0x0L, 0x0L);
0282       case 108:
0283          return jjMoveStringLiteralDfa1_0(0x8000000000000L, 0x0L, 0x0L);
0284       case 110:
0285          return jjMoveStringLiteralDfa1_0(0x70000000000000L, 0x0L, 0x0L);
0286       case 112:
0287          return jjMoveStringLiteralDfa1_0(0x780000000000000L, 0x0L, 0x0L);
0288       case 114:
0289          return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x0L, 0x0L);
0290       case 115:
0291          return jjMoveStringLiteralDfa1_0(0xf000000000000000L, 0x3L, 0x0L);
0292       case 116:
0293          return jjMoveStringLiteralDfa1_0(0x0L, 0xfcL, 0x0L);
0294       case 118:
0295          return jjMoveStringLiteralDfa1_0(0x0L, 0x300L, 0x0L);
0296       case 119:
0297          return jjMoveStringLiteralDfa1_0(0x0L, 0x400L, 0x0L);
0298       case 123:
0299          return jjStopAtPos(0, 88);
0300       case 124:
0301          jjmatchedKind = 115;
0302          return jjMoveStringLiteralDfa1_0(0x0L, 0x800040000000000L, 0x0L);
0303       case 125:
0304          return jjStopAtPos(0, 89);
0305       case 126:
0306          return jjStopAtPos(0, 99);
0307       default :
0308          return jjMoveNfa_0(3, 0);
0309    }
0310 }
0311 private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2)
0312 {
0313    try { curChar = input_stream.readChar(); }
0314    catch(java.io.IOException e) {
0315       jjStopStringLiteralDfa_0(0, active0, active1, active2);
0316       return 1;
0317    }
0318    switch(curChar)
0319    {
0320       case 38:
0321          if ((active1 & 0x80000000000L) != 0L)
0322             return jjStopAtPos(1, 107);
0323          break;
0324       case 42:
0325          if ((active0 & 0x80000L) != 0L)
0326             return jjStartNfaWithStates_0(1, 19, 0);
0327          break;
0328       case 43:
0329          if ((active1 & 0x100000000000L) != 0L)
0330             return jjStopAtPos(1, 108);
0331          break;
0332       case 45:
0333          if ((active1 & 0x200000000000L) != 0L)
0334             return jjStopAtPos(1, 109);
0335          break;
0336       case 46:
0337          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000000000000L, active2, 0L);
0338       case 47:
0339          if ((active0 & 0x20000L) != 0L)
0340             return jjStopAtPos(1, 17);
0341          break;
0342       case 60:
0343          if ((active2 & 0x80L) != 0L)
0344          {
0345             jjmatchedKind = 135;
0346             jjmatchedPos = 1;
0347          }
0348          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x10L);
0349       case 61:
0350          if ((active1 & 0x4000000000L) != 0L)
0351             return jjStopAtPos(1, 102);
0352          else if ((active1 & 0x8000000000L) != 0L)
0353             return jjStopAtPos(1, 103);
0354          else if ((active1 & 0x10000000000L) != 0L)
0355             return jjStopAtPos(1, 104);
0356          else if ((active1 & 0x20000000000L) != 0L)
0357             return jjStopAtPos(1, 105);
0358          else if ((active1 & 0x40000000000000L) != 0L)
0359             return jjStopAtPos(1, 118);
0360          else if ((active1 & 0x80000000000000L) != 0L)
0361             return jjStopAtPos(1, 119);
0362          else if ((active1 & 0x100000000000000L) != 0L)
0363             return jjStopAtPos(1, 120);
0364          else if ((active1 & 0x200000000000000L) != 0L)
0365             return jjStopAtPos(1, 121);
0366          else if ((active1 & 0x400000000000000L) != 0L)
0367             return jjStopAtPos(1, 122);
0368          else if ((active1 & 0x800000000000000L) != 0L)
0369             return jjStopAtPos(1, 123);
0370          else if ((active1 & 0x1000000000000000L) != 0L)
0371             return jjStopAtPos(1, 124);
0372          else if ((active1 & 0x2000000000000000L) != 0L)
0373             return jjStopAtPos(1, 125);
0374          break;
0375       case 62:
0376          if ((active2 & 0x1L) != 0L)
0377          {
0378             jjmatchedKind = 128;
0379             jjmatchedPos = 1;
0380          }
0381          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000000000000L, active2, 0x60L);
0382       case 65:
0383          return jjMoveStringLiteralDfa2_0(active0, 0x38L, active1, 0L, active2, 0L);
0384       case 71:
0385          return jjMoveStringLiteralDfa2_0(active0, 0x4L, active1, 0L, active2, 0L);
0386       case 75:
0387          return jjMoveStringLiteralDfa2_0(active0, 0x200L, active1, 0L, active2, 0L);
0388       case 79:
0389          return jjMoveStringLiteralDfa2_0(active0, 0xd42L, active1, 0L, active2, 0L);
0390       case 80:
0391          return jjMoveStringLiteralDfa2_0(active0, 0x80L, active1, 0L, active2, 0L);
0392       case 97:
0393          return jjMoveStringLiteralDfa2_0(active0, 0x90008030000000L, active1, 0L, active2, 0L);
0394       case 98:
0395          return jjMoveStringLiteralDfa2_0(active0, 0x1000000L, active1, 0L, active2, 0L);
0396       case 101:
0397          return jjMoveStringLiteralDfa2_0(active0, 0x820000400000000L, active1, 0L, active2, 0L);
0398       case 102:
0399          if ((active0 & 0x200000000000L) != 0L)
0400             return jjStartNfaWithStates_0(1, 45, 32);
0401          break;
0402       case 104:
0403          return jjMoveStringLiteralDfa2_0(active0, 0x1000000040000000L, active1, 0x41cL, active2, 0L);
0404       case 105:
0405          return jjMoveStringLiteralDfa2_0(active0, 0x30000000000L, active1, 0L, active2, 0L);
0406       case 108:
0407          return jjMoveStringLiteralDfa2_0(active0, 0x42080000000L, active1, 0L, active2, 0L);
0408       case 109:
0409          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000000L, active1, 0L, active2, 0L);
0410       case 110:
0411          return jjMoveStringLiteralDfa2_0(active0, 0x7000000000000L, active1, 0L, active2, 0x8L);
0412       case 111:
0413          if ((active0 & 0x800000000L) != 0L)
0414          {
0415             jjmatchedKind = 35;
0416             jjmatchedPos = 1;
0417          }
0418          return jjMoveStringLiteralDfa2_0(active0, 0x8181302000000L, active1, 0x300L, active2, 0L);
0419       case 114:
0420          return jjMoveStringLiteralDfa2_0(active0, 0x300000004000000L, active1, 0xe0L, active2, 0L);
0421       case 115:
0422          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x100L);
0423       case 116:
0424          return jjMoveStringLiteralDfa2_0(active0, 0x6000000000000000L, active1, 0L, active2, 0L);
0425       case 117:
0426          return jjMoveStringLiteralDfa2_0(active0, 0x8440000000000000L, active1, 0L, active2, 0L);
0427       case 119:
0428          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1L, active2, 0L);
0429       case 120:
0430          return jjMoveStringLiteralDfa2_0(active0, 0x4000000000L, active1, 0L, active2, 0L);
0431       case 121:
0432          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0x2L, active2, 0L);
0433       case 124:
0434          if ((active1 & 0x40000000000L) != 0L)
0435             return jjStopAtPos(1, 106);
0436          break;
0437       default :
0438          break;
0439    }
0440    return jjStartNfa_0(0, active0, active1, active2);
0441 }
0442 private int jjMoveStringLiteralDfa2_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(0, old0, old1, old2);
0446    try { curChar = input_stream.readChar(); }
0447    catch(java.io.IOException e) {
0448       jjStopStringLiteralDfa_0(1, active0, active1, active2);
0449       return 2;
0450    }
0451    switch(curChar)
0452    {
0453       case 46:
0454          if ((active1 & 0x4000000000000000L) != 0L)
0455             return jjStopAtPos(2, 126);
0456          break;
0457       case 61:
0458          if ((active2 & 0x10L) != 0L)
0459             return jjStopAtPos(2, 132);
0460          else if ((active2 & 0x20L) != 0L)
0461             return jjStopAtPos(2, 133);
0462          break;
0463       case 62:
0464          if ((active1 & 0x8000000000000000L) != 0L)
0465          {
0466             jjmatchedKind = 127;
0467             jjmatchedPos = 2;
0468          }
0469          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x40L);
0470       case 69:
0471          return jjMoveStringLiteralDfa3_0(active0, 0x80L, active1, 0L, active2, 0L);
0472       case 70:
0473          if ((active0 & 0x800L) != 0L)
0474             return jjStartNfaWithStates_0(2, 11, 32);
0475          break;
0476       case 73:
0477          return jjMoveStringLiteralDfa3_0(active0, 0x200L, active1, 0L, active2, 0L);
0478       case 75:
0479          return jjMoveStringLiteralDfa3_0(active0, 0x440L, active1, 0L, active2, 0L);
0480       case 78:
0481          return jjMoveStringLiteralDfa3_0(active0, 0x4L, active1, 0L, active2, 0L);
0482       case 79:
0483          return jjMoveStringLiteralDfa3_0(active0, 0x2L, active1, 0L, active2, 0L);
0484       case 82:
0485          return jjMoveStringLiteralDfa3_0(active0, 0x118L, active1, 0L, active2, 0L);
0486       case 86:
0487          return jjMoveStringLiteralDfa3_0(active0, 0x20L, active1, 0L, active2, 0L);
0488       case 97:
0489          return jjMoveStringLiteralDfa3_0(active0, 0x20000000c0000000L, active1, 0x20L, active2, 0L);
0490       case 98:
0491          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000000L, active1, 0L, active2, 0L);
0492       case 99:
0493          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000000L, active1, 0L, active2, 0L);
0494       case 101:
0495          return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L, active2, 0L);
0496       case 102:
0497          return jjMoveStringLiteralDfa3_0(active0, 0x400000000L, active1, 0L, active2, 0L);
0498       case 105:
0499          return jjMoveStringLiteralDfa3_0(active0, 0x100000000000000L, active1, 0x505L, active2, 0L);
0500       case 108:
0501          return jjMoveStringLiteralDfa3_0(active0, 0x40008000000000L, active1, 0x200L, active2, 0L);
0502       case 110:
0503          return jjMoveStringLiteralDfa3_0(active0, 0x8030300000000L, active1, 0x2L, active2, 0L);
0504       case 111:
0505          return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000000L, active1, 0L, active2, 0L);
0506       case 112:
0507          return jjMoveStringLiteralDfa3_0(active0, 0x8000c00000000000L, active1, 0L, active2, 0L);
0508       case 114:
0509          if ((active0 & 0x80000000000L) != 0L)
0510             return jjStartNfaWithStates_0(2, 43, 32);
0511          return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000000L, active1, 0x18L, active2, 0L);
0512       case 115:
0513          return jjMoveStringLiteralDfa3_0(active0, 0x1002011000000L, active1, 0L, active2, 0x100L);
0514       case 116:
0515          if ((active0 & 0x2000000000000L) != 0L)
0516          {
0517             jjmatchedKind = 49;
0518             jjmatchedPos = 2;
0519          }
0520          return jjMoveStringLiteralDfa3_0(active0, 0x814104028000000L, active1, 0L, active2, 0L);
0521       case 117:
0522          return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L, active1, 0x40L, active2, 0x8L);
0523       case 119:
0524          if ((active0 & 0x20000000000000L) != 0L)
0525             return jjStartNfaWithStates_0(2, 53, 32);
0526          break;
0527       case 121:
0528          if ((active1 & 0x80L) != 0L)
0529             return jjStartNfaWithStates_0(2, 71, 32);
0530          break;
0531       default :
0532          break;
0533    }
0534    return jjStartNfa_0(1, active0, active1, active2);
0535 }
0536 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2)
0537 {
0538    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0539       return jjStartNfa_0(1, old0, old1, old2);
0540    try { curChar = input_stream.readChar(); }
0541    catch(java.io.IOException e) {
0542       jjStopStringLiteralDfa_0(2, active0, active1, active2);
0543       return 3;
0544    }
0545    switch(curChar)
0546    {
0547       case 61:
0548          if ((active2 & 0x40L) != 0L)
0549             return jjStopAtPos(3, 134);
0550          break;
0551       case 65:
0552          return jjMoveStringLiteralDfa4_0(active0, 0x20L, active1, 0L, active2, 0L);
0553       case 67:
0554          return jjMoveStringLiteralDfa4_0(active0, 0x80L, active1, 0L, active2, 0L);
0555       case 69:
0556          if ((active0 & 0x100L) != 0L)
0557             return jjStartNfaWithStates_0(3, 8, 32);
0558          return jjMoveStringLiteralDfa4_0(active0, 0x440L, active1, 0L, active2, 0L);
0559       case 75:
0560          return jjMoveStringLiteralDfa4_0(active0, 0x2L, active1, 0L, active2, 0L);
0561       case 79:
0562          return jjMoveStringLiteralDfa4_0(active0, 0x4L, active1, 0L, active2, 0L);
0563       case 80:
0564          if ((active0 & 0x200L) != 0L)
0565             return jjStartNfaWithStates_0(3, 9, 32);
0566          break;
0567       case 83:
0568          return jjMoveStringLiteralDfa4_0(active0, 0x18L, active1, 0L, active2, 0L);
0569       case 97:
0570          return jjMoveStringLiteralDfa4_0(active0, 0x70404000000L, active1, 0x200L, active2, 0L);
0571       case 98:
0572          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000L, active1, 0L, active2, 0L);
0573       case 99:
0574          return jjMoveStringLiteralDfa4_0(active0, 0x20000000L, active1, 0x2L, active2, 0L);
0575       case 100:
0576          if ((active1 & 0x100L) != 0L)
0577             return jjStartNfaWithStates_0(3, 72, 32);
0578          break;
0579       case 101:
0580          if ((active0 & 0x8000000L) != 0L)
0581             return jjStartNfaWithStates_0(3, 27, 32);
0582          else if ((active0 & 0x10000000L) != 0L)
0583             return jjStartNfaWithStates_0(3, 28, 32);
0584          else if ((active0 & 0x2000000000L) != 0L)
0585             return jjStartNfaWithStates_0(3, 37, 32);
0586          else if ((active1 & 0x40L) != 0L)
0587             return jjStartNfaWithStates_0(3, 70, 32);
0588          return jjMoveStringLiteralDfa4_0(active0, 0x8004004000000000L, active1, 0L, active2, 0x100L);
0589       case 103:
0590          if ((active0 & 0x8000000000000L) != 0L)
0591             return jjStartNfaWithStates_0(3, 51, 32);
0592          break;
0593       case 105:
0594          return jjMoveStringLiteralDfa4_0(active0, 0x4010000000000000L, active1, 0L, active2, 0L);
0595       case 107:
0596          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0L, active2, 0L);
0597       case 108:
0598          if ((active0 & 0x40000000000000L) != 0L)
0599             return jjStartNfaWithStates_0(3, 54, 32);
0600          return jjMoveStringLiteralDfa4_0(active0, 0x400400002000000L, active1, 0x400L, active2, 0L);
0601       case 109:
0602          if ((active2 & 0x8L) != 0L)
0603             return jjStartNfaWithStates_0(3, 131, 32);
0604          break;
0605       case 110:
0606          return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20L, active2, 0L);
0607       case 111:
0608          if ((active0 & 0x100000000000L) != 0L)
0609             return jjStartNfaWithStates_0(3, 44, 32);
0610          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0x18L, active2, 0L);
0611       case 114:
0612          if ((active0 & 0x40000000L) != 0L)
0613             return jjStartNfaWithStates_0(3, 30, 32);
0614          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0L, active2, 0L);
0615       case 115:
0616          if ((active1 & 0x4L) != 0L)
0617             return jjStartNfaWithStates_0(3, 66, 32);
0618          return jjMoveStringLiteralDfa4_0(active0, 0x8180000000L, active1, 0L, active2, 0L);
0619       case 116:
0620          return jjMoveStringLiteralDfa4_0(active0, 0x2201000201000000L, active1, 0x1L, active2, 0L);
0621       case 117:
0622          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L, active2, 0L);
0623       case 118:
0624          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L, active2, 0L);
0625       default :
0626          break;
0627    }
0628    return jjStartNfa_0(2, active0, active1, active2);
0629 }
0630 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2)
0631 {
0632    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0633       return jjStartNfa_0(2, old0, old1, old2);
0634    try { curChar = input_stream.readChar(); }
0635    catch(java.io.IOException e) {
0636       jjStopStringLiteralDfa_0(3, active0, active1, active2);
0637       return 4;
0638    }
0639    switch(curChar)
0640    {
0641       case 65:
0642          return jjMoveStringLiteralDfa5_0(active0, 0x2L, active1, 0L, active2, 0L);
0643       case 67:
0644          return jjMoveStringLiteralDfa5_0(active0, 0x20L, active1, 0L, active2, 0L);
0645       case 69:
0646          return jjMoveStringLiteralDfa5_0(active0, 0x18L, active1, 0L, active2, 0L);
0647       case 73:
0648          return jjMoveStringLiteralDfa5_0(active0, 0x80L, active1, 0L, active2, 0L);
0649       case 78:
0650          if ((active0 & 0x40L) != 0L)
0651          {
0652             jjmatchedKind = 6;
0653             jjmatchedPos = 4;
0654          }
0655          return jjMoveStringLiteralDfa5_0(active0, 0x400L, active1, 0L, active2, 0L);
0656       case 82:
0657          return jjMoveStringLiteralDfa5_0(active0, 0x4L, active1, 0L, active2, 0L);
0658       case 97:
0659          return jjMoveStringLiteralDfa5_0(active0, 0x181000000000000L, active1, 0L, active2, 0L);
0660       case 99:
0661          return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000000L, active1, 0x1L, active2, 0L);
0662       case 101:
0663          if ((active0 & 0x8000000000L) != 0L)
0664             return jjStartNfaWithStates_0(4, 39, 32);
0665          else if ((active1 & 0x400L) != 0L)
0666             return jjStartNfaWithStates_0(4, 74, 32);
0667          return jjMoveStringLiteralDfa5_0(active0, 0x200400002000000L, active1, 0L, active2, 0L);
0668       case 104:
0669          if ((active0 & 0x20000000L) != 0L)
0670             return jjStartNfaWithStates_0(4, 29, 32);
0671          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x2L, active2, 0L);
0672       case 105:
0673          return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000000L, active1, 0L, active2, 0L);
0674       case 107:
0675          if ((active0 & 0x4000000L) != 0L)
0676             return jjStartNfaWithStates_0(4, 26, 32);
0677          break;
0678       case 108:
0679          if ((active0 & 0x10000000000L) != 0L)
0680          {
0681             jjmatchedKind = 40;
0682             jjmatchedPos = 4;
0683          }
0684          return jjMoveStringLiteralDfa5_0(active0, 0x21000000000L, active1, 0L, active2, 0L);
0685       case 110:
0686          return jjMoveStringLiteralDfa5_0(active0, 0x4000000000L, active1, 0L, active2, 0L);
0687       case 114:
0688          if ((active0 & 0x8000000000000000L) != 0L)
0689             return jjStartNfaWithStates_0(4, 63, 32);
0690          return jjMoveStringLiteralDfa5_0(active0, 0x804800001000000L, active1, 0L, active2, 0x100L);
0691       case 115:
0692          if ((active0 & 0x80000000L) != 0L)
0693             return jjStartNfaWithStates_0(4, 31, 32);
0694          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x20L, active2, 0L);
0695       case 116:
0696          if ((active0 & 0x100000000L) != 0L)
0697             return jjStartNfaWithStates_0(4, 32, 32);
0698          else if ((active0 & 0x40000000000L) != 0L)
0699             return jjStartNfaWithStates_0(4, 42, 32);
0700          else if ((active0 & 0x1000000000000000L) != 0L)
0701             return jjStartNfaWithStates_0(4, 60, 32);
0702          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x200L, active2, 0L);
0703       case 117:
0704          return jjMoveStringLiteralDfa5_0(active0, 0x400000000L, active1, 0L, active2, 0L);
0705       case 118:
0706          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L, active1, 0L, active2, 0L);
0707       case 119:
0708          if ((active1 & 0x8L) != 0L)
0709          {
0710             jjmatchedKind = 67;
0711             jjmatchedPos = 4;
0712          }
0713          return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x10L, active2, 0L);
0714       default :
0715          break;
0716    }
0717    return jjStartNfa_0(3, active0, active1, active2);
0718 }
0719 private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1, long old2, long active2)
0720 {
0721    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0722       return jjStartNfa_0(3, old0, old1, old2);
0723    try { curChar = input_stream.readChar(); }
0724    catch(java.io.IOException e) {
0725       jjStopStringLiteralDfa_0(4, active0, active1, active2);
0726       return 5;
0727    }
0728    switch(curChar)
0729    {
0730       case 65:
0731          return jjMoveStringLiteralDfa6_0(active0, 0x80L, active1, 0L, active2, 0L);
0732       case 69:
0733          return jjMoveStringLiteralDfa6_0(active0, 0x4L, active1, 0L, active2, 0L);
0734       case 72:
0735          return jjMoveStringLiteralDfa6_0(active0, 0x2L, active1, 0L, active2, 0L);
0736       case 79:
0737          return jjMoveStringLiteralDfa6_0(active0, 0x20L, active1, 0L, active2, 0L);
0738       case 82:
0739          return jjMoveStringLiteralDfa6_0(active0, 0x18L, active1, 0L, active2, 0L);
0740       case 95:
0741          return jjMoveStringLiteralDfa6_0(active0, 0x400L, active1, 0L, active2, 0L);
0742       case 97:
0743          return jjMoveStringLiteralDfa6_0(active0, 0x3000000L, active1, 0L, active2, 0L);
0744       case 99:
0745          if ((active0 & 0x400000000000000L) != 0L)
0746             return jjStartNfaWithStates_0(5, 58, 32);
0747          else if ((active0 & 0x2000000000000000L) != 0L)
0748             return jjStartNfaWithStates_0(5, 61, 32);
0749          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000000L, active1, 0L, active2, 0L);
0750       case 100:
0751          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L, active1, 0L, active2, 0L);
0752       case 101:
0753          if ((active0 & 0x1000000000L) != 0L)
0754             return jjStartNfaWithStates_0(5, 36, 32);
0755          else if ((active0 & 0x10000000000000L) != 0L)
0756             return jjStartNfaWithStates_0(5, 52, 32);
0757          break;
0758       case 102:
0759          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000000L, active1, 0L, active2, 0L);
0760       case 103:
0761          return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L, active1, 0L, active2, 0L);
0762       case 104:
0763          if ((active1 & 0x1L) != 0L)
0764             return jjStartNfaWithStates_0(5, 64, 32);
0765          break;
0766       case 105:
0767          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x220L, active2, 0L);
0768       case 108:
0769          return jjMoveStringLiteralDfa6_0(active0, 0x20400000000L, active1, 0L, active2, 0L);
0770       case 109:
0771          return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L, active2, 0L);
0772       case 110:
0773          if ((active0 & 0x800000000000000L) != 0L)
0774             return jjStartNfaWithStates_0(5, 59, 32);
0775          return jjMoveStringLiteralDfa6_0(active0, 0x1000200000000L, active1, 0L, active2, 0L);
0776       case 114:
0777          return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2L, active2, 0L);
0778       case 115:
0779          if ((active1 & 0x10L) != 0L)
0780             return jjStartNfaWithStates_0(5, 68, 32);
0781          break;
0782       case 116:
0783          if ((active0 & 0x800000000000L) != 0L)
0784             return jjStartNfaWithStates_0(5, 47, 32);
0785          else if ((active2 & 0x100L) != 0L)
0786             return jjStartNfaWithStates_0(5, 136, 32);
0787          return jjMoveStringLiteralDfa6_0(active0, 0x4100000000000000L, active1, 0L, active2, 0L);
0788       default :
0789          break;
0790    }
0791    return jjStartNfa_0(4, active0, active1, active2);
0792 }
0793 private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1, long old2, long active2)
0794 {
0795    if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
0796       return jjStartNfa_0(4, old0, old1, old2);
0797    try { curChar = input_stream.readChar(); }
0798    catch(java.io.IOException e) {
0799       jjStopStringLiteralDfa_0(5, active0, active1, 0L);
0800       return 6;
0801    }
0802    switch(curChar)
0803    {
0804       case 68:
0805          return jjMoveStringLiteralDfa7_0(active0, 0x20L, active1, 0L);
0806       case 69:
0807          return jjMoveStringLiteralDfa7_0(active0, 0x2L, active1, 0L);
0808       case 76:
0809          return jjMoveStringLiteralDfa7_0(active0, 0x80L, active1, 0L);
0810       case 77:
0811          return jjMoveStringLiteralDfa7_0(active0, 0x400L, active1, 0L);
0812       case 95:
0813          return jjMoveStringLiteralDfa7_0(active0, 0x1cL, active1, 0L);
0814       case 97:
0815          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L, active1, 0L);
0816       case 99:
0817          return jjMoveStringLiteralDfa7_0(active0, 0x1000001000000L, active1, 0L);
0818       case 101:
0819          if ((active0 & 0x80000000000000L) != 0L)
0820             return jjStartNfaWithStates_0(6, 55, 32);
0821          else if ((active0 & 0x100000000000000L) != 0L)
0822             return jjStartNfaWithStates_0(6, 56, 32);
0823          return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0x20L);
0824       case 102:
0825          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L, active1, 0L);
0826       case 108:
0827          return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x200L);
0828       case 110:
0829          if ((active0 & 0x2000000L) != 0L)
0830             return jjStartNfaWithStates_0(6, 25, 32);
0831          break;
0832       case 111:
0833          return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x2L);
0834       case 115:
0835          if ((active0 & 0x4000000000L) != 0L)
0836             return jjStartNfaWithStates_0(6, 38, 32);
0837          break;
0838       case 116:
0839          if ((active0 & 0x400000000L) != 0L)
0840             return jjStartNfaWithStates_0(6, 34, 32);
0841          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000000L, active1, 0L);
0842       case 117:
0843          return jjMoveStringLiteralDfa7_0(active0, 0x200000000L, active1, 0L);
0844       case 121:
0845          if ((active0 & 0x20000000000L) != 0L)
0846             return jjStartNfaWithStates_0(6, 41, 32);
0847          break;
0848       default :
0849          break;
0850    }
0851    return jjStartNfa_0(5, active0, active1, 0L);
0852 }
0853 private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
0854 {
0855    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0856       return jjStartNfa_0(5, old0, old1, 0L);
0857    try { curChar = input_stream.readChar(); }
0858    catch(java.io.IOException e) {
0859       jjStopStringLiteralDfa_0(6, active0, active1, 0L);
0860       return 7;
0861    }
0862    switch(curChar)
0863    {
0864       case 65:
0865          return jjMoveStringLiteralDfa8_0(active0, 0x2L, active1, 0L);
0866       case 66:
0867          return jjMoveStringLiteralDfa8_0(active0, 0x8L, active1, 0L);
0868       case 67:
0869          return jjMoveStringLiteralDfa8_0(active0, 0x4L, active1, 0L);
0870       case 69:
0871          if ((active0 & 0x20L) != 0L)
0872             return jjStartNfaWithStates_0(7, 5, 32);
0873          return jjMoveStringLiteralDfa8_0(active0, 0x10L, active1, 0L);
0874       case 71:
0875          return jjMoveStringLiteralDfa8_0(active0, 0x400L, active1, 0L);
0876       case 95:
0877          return jjMoveStringLiteralDfa8_0(active0, 0x80L, active1, 0L);
0878       case 99:
0879          return jjMoveStringLiteralDfa8_0(active0, 0x4000000000000L, active1, 0L);
0880       case 101:
0881          if ((active0 & 0x200000000L) != 0L)
0882             return jjStartNfaWithStates_0(7, 33, 32);
0883          else if ((active1 & 0x200L) != 0L)
0884             return jjStartNfaWithStates_0(7, 73, 32);
0885          return jjMoveStringLiteralDfa8_0(active0, 0x201000000000000L, active1, 0L);
0886       case 110:
0887          return jjMoveStringLiteralDfa8_0(active0, 0x400000000000L, active1, 0x22L);
0888       case 112:
0889          if ((active0 & 0x4000000000000000L) != 0L)
0890             return jjStartNfaWithStates_0(7, 62, 32);
0891          break;
0892       case 116:
0893          if ((active0 & 0x1000000L) != 0L)
0894             return jjStartNfaWithStates_0(7, 24, 32);
0895          break;
0896       default :
0897          break;
0898    }
0899    return jjStartNfa_0(6, active0, active1, 0L);
0900 }
0901 private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
0902 {
0903    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0904       return jjStartNfa_0(6, old0, old1, 0L);
0905    try { curChar = input_stream.readChar(); }
0906    catch(java.io.IOException e) {
0907       jjStopStringLiteralDfa_0(7, active0, active1, 0L);
0908       return 8;
0909    }
0910    switch(curChar)
0911    {
0912       case 65:
0913          return jjMoveStringLiteralDfa9_0(active0, 0x4L, active1, 0L);
0914       case 68:
0915          if ((active0 & 0x2L) != 0L)
0916             return jjStartNfaWithStates_0(8, 1, 32);
0917          break;
0918       case 69:
0919          return jjMoveStringLiteralDfa9_0(active0, 0x8L, active1, 0L);
0920       case 78:
0921          return jjMoveStringLiteralDfa9_0(active0, 0x10L, active1, 0L);
0922       case 82:
0923          return jjMoveStringLiteralDfa9_0(active0, 0x400L, active1, 0L);
0924       case 84:
0925          return jjMoveStringLiteralDfa9_0(active0, 0x80L, active1, 0L);
0926       case 100:
0927          if ((active0 & 0x200000000000000L) != 0L)
0928             return jjStartNfaWithStates_0(8, 57, 32);
0929          break;
0930       case 101:
0931          if ((active0 & 0x4000000000000L) != 0L)
0932             return jjStartNfaWithStates_0(8, 50, 32);
0933          break;
0934       case 105:
0935          return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x2L);
0936       case 111:
0937          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000000L, active1, 0L);
0938       case 116:
0939          if ((active1 & 0x20L) != 0L)
0940             return jjStartNfaWithStates_0(8, 69, 32);
0941          return jjMoveStringLiteralDfa9_0(active0, 0x400000000000L, active1, 0L);
0942       default :
0943          break;
0944    }
0945    return jjStartNfa_0(7, active0, active1, 0L);
0946 }
0947 private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
0948 {
0949    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0950       return jjStartNfa_0(7, old0, old1, 0L);
0951    try { curChar = input_stream.readChar(); }
0952    catch(java.io.IOException e) {
0953       jjStopStringLiteralDfa_0(8, active0, active1, 0L);
0954       return 9;
0955    }
0956    switch(curChar)
0957    {
0958       case 68:
0959          if ((active0 & 0x10L) != 0L)
0960             return jjStartNfaWithStates_0(9, 4, 32);
0961          break;
0962       case 71:
0963          return jjMoveStringLiteralDfa10_0(active0, 0x8L, active1, 0L);
0964       case 79:
0965          return jjMoveStringLiteralDfa10_0(active0, 0x80L, active1, 0L);
0966       case 83:
0967          return jjMoveStringLiteralDfa10_0(active0, 0x4L, active1, 0L);
0968       case 95:
0969          return jjMoveStringLiteralDfa10_0(active0, 0x400L, active1, 0L);
0970       case 102:
0971          if ((active0 & 0x1000000000000L) != 0L)
0972             return jjStartNfaWithStates_0(9, 48, 32);
0973          break;
0974       case 115:
0975          if ((active0 & 0x400000000000L) != 0L)
0976             return jjStartNfaWithStates_0(9, 46, 32);
0977          break;
0978       case 122:
0979          return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x2L);
0980       default :
0981          break;
0982    }
0983    return jjStartNfa_0(8, active0, active1, 0L);
0984 }
0985 private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1)
0986 {
0987    if (((active0 &= old0) | (active1 &= old1)) == 0L)
0988       return jjStartNfa_0(8, old0, old1, 0L);
0989    try { curChar = input_stream.readChar(); }
0990    catch(java.io.IOException e) {
0991       jjStopStringLiteralDfa_0(9, active0, active1, 0L);
0992       return 10;
0993    }
0994    switch(curChar)
0995    {
0996       case 68:
0997          return jjMoveStringLiteralDfa11_0(active0, 0x400L, active1, 0L);
0998       case 69:
0999          if ((active0 & 0x4L) != 0L)
1000             return jjStartNfaWithStates_0(10, 2, 32);
1001          break;
1002       case 73:
1003          return jjMoveStringLiteralDfa11_0(active0, 0x8L, active1, 0L);
1004       case 75:
1005          return jjMoveStringLiteralDfa11_0(active0, 0x80L, active1, 0L);
1006       case 101:
1007          return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x2L);
1008       default :
1009          break;
1010    }
1011    return jjStartNfa_0(9, active0, active1, 0L);
1012 }
1013 private int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1)
1014 {
1015    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1016       return jjStartNfa_0(9, old0, old1, 0L);
1017    try { curChar = input_stream.readChar(); }
1018    catch(java.io.IOException e) {
1019       jjStopStringLiteralDfa_0(10, active0, active1, 0L);
1020       return 11;
1021    }
1022    switch(curChar)
1023    {
1024       case 69:
1025          return jjMoveStringLiteralDfa12_0(active0, 0x480L, active1, 0L);
1026       case 78:
1027          if ((active0 & 0x8L) != 0L)
1028             return jjStartNfaWithStates_0(11, 3, 32);
1029          break;
1030       case 100:
1031          if ((active1 & 0x2L) != 0L)
1032             return jjStartNfaWithStates_0(11, 65, 32);
1033          break;
1034       default :
1035          break;
1036    }
1037    return jjStartNfa_0(10, active0, active1, 0L);
1038 }
1039 private int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long active1)
1040 {
1041    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1042       return jjStartNfa_0(10, old0, old1, 0L);
1043    try { curChar = input_stream.readChar(); }
1044    catch(java.io.IOException e) {
1045       jjStopStringLiteralDfa_0(11, active0, 0L, 0L);
1046       return 12;
1047    }
1048    switch(curChar)
1049    {
1050       case 67:
1051          return jjMoveStringLiteralDfa13_0(active0, 0x400L);
1052       case 78:
1053          if ((active0 & 0x80L) != 0L)
1054             return jjStartNfaWithStates_0(12, 7, 32);
1055          break;
1056       default :
1057          break;
1058    }
1059    return jjStartNfa_0(11, active0, 0L, 0L);
1060 }
1061 private int jjMoveStringLiteralDfa13_0(long old0, long active0)
1062 {
1063    if (((active0 &= old0)) == 0L)
1064       return jjStartNfa_0(11, old0, 0L, 0L);
1065    try { curChar = input_stream.readChar(); }
1066    catch(java.io.IOException e) {
1067       jjStopStringLiteralDfa_0(12, active0, 0L, 0L);
1068       return 13;
1069    }
1070    switch(curChar)
1071    {
1072       case 76:
1073          return jjMoveStringLiteralDfa14_0(active0, 0x400L);
1074       default :
1075          break;
1076    }
1077    return jjStartNfa_0(12, active0, 0L, 0L);
1078 }
1079 private int jjMoveStringLiteralDfa14_0(long old0, long active0)
1080 {
1081    if (((active0 &= old0)) == 0L)
1082       return jjStartNfa_0(12, old0, 0L, 0L);
1083    try { curChar = input_stream.readChar(); }
1084    catch(java.io.IOException e) {
1085       jjStopStringLiteralDfa_0(13, active0, 0L, 0L);
1086       return 14;
1087    }
1088    switch(curChar)
1089    {
1090       case 83:
1091          if ((active0 & 0x400L) != 0L)
1092             return jjStartNfaWithStates_0(14, 10, 32);
1093          break;
1094       default :
1095          break;
1096    }
1097    return jjStartNfa_0(13, active0, 0L, 0L);
1098 }
1099 private int jjStartNfaWithStates_0(int pos, int kind, int state)
1100 {
1101    jjmatchedKind = kind;
1102    jjmatchedPos = pos;
1103    try { curChar = input_stream.readChar(); }
1104    catch(java.io.IOException e) { return pos + 1; }
1105    return jjMoveNfa_0(state, pos + 1);
1106 }
1107 static final long[] jjbitVec0 = {
1108    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
1109 };
1110 static final long[] jjbitVec2 = {
1111    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1112 };
1113 static final long[] jjbitVec3 = {
1114    0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
1115 };
1116 static final long[] jjbitVec4 = {
1117    0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
1118 };
1119 static final long[] jjbitVec5 = {
1120    0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
1121 };
1122 static final long[] jjbitVec6 = {
1123    0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
1124 };
1125 static final long[] jjbitVec7 = {
1126    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
1127 };
1128 static final long[] jjbitVec8 = {
1129    0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
1130 };
1131 static final long[] jjbitVec9 = {
1132    0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
1133 };
1134 static final long[] jjbitVec10 = {
1135    0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
1136 };
1137 static final long[] jjbitVec11 = {
1138    0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
1139 };
1140 static final long[] jjbitVec12 = {
1141    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
1142 };
1143 static final long[] jjbitVec13 = {
1144    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
1145 };
1146 static final long[] jjbitVec14 = {
1147    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
1148 };
1149 static final long[] jjbitVec15 = {
1150    0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
1151 };
1152 static final long[] jjbitVec16 = {
1153    0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
1154 };
1155 static final long[] jjbitVec17 = {
1156    0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
1157 };
1158 static final long[] jjbitVec18 = {
1159    0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
1160 };
1161 static final long[] jjbitVec19 = {
1162    0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
1163 };
1164 static final long[] jjbitVec20 = {
1165    0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
1166 };
1167 static final long[] jjbitVec21 = {
1168    0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1169 };
1170 static final long[] jjbitVec22 = {
1171    0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
1172 };
1173 static final long[] jjbitVec23 = {
1174    0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
1175 };
1176 static final long[] jjbitVec24 = {
1177    0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
1178 };
1179 static final long[] jjbitVec25 = {
1180    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
1181 };
1182 static final long[] jjbitVec26 = {
1183    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
1184 };
1185 static final long[] jjbitVec27 = {
1186    0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
1187 };
1188 static final long[] jjbitVec28 = {
1189    0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
1190 };
1191 static final long[] jjbitVec29 = {
1192    0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
1193 };
1194 static final long[] jjbitVec30 = {
1195    0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
1196 };
1197 static final long[] jjbitVec31 = {
1198    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
1199 };
1200 static final long[] jjbitVec32 = {
1201    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
1202 };
1203 static final long[] jjbitVec33 = {
1204    0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
1205 };
1206 static final long[] jjbitVec34 = {
1207    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
1208 };
1209 static final long[] jjbitVec35 = {
1210    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
1211 };
1212 static final long[] jjbitVec36 = {
1213    0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1214 };
1215 static final long[] jjbitVec37 = {
1216    0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
1217 };
1218 static final long[] jjbitVec38 = {
1219    0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
1220 };
1221 static final long[] jjbitVec39 = {
1222    0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
1223 };
1224 static final long[] jjbitVec40 = {
1225    0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
1226 };
1227 static final long[] jjbitVec41 = {
1228    0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
1229 };
1230 static final long[] jjbitVec42 = {
1231    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
1232 };
1233 static final long[] jjbitVec43 = {
1234    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
1235 };
1236 static final long[] jjbitVec44 = {
1237    0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
1238 };
1239 static final long[] jjbitVec45 = {
1240    0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
1241 };
1242 static final long[] jjbitVec46 = {
1243    0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
1244 };
1245 static final long[] jjbitVec47 = {
1246    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
1247 };
1248 static final long[] jjbitVec48 = {
1249    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1250 };
1251 static final long[] jjbitVec49 = {
1252    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1253 };
1254 static final long[] jjbitVec50 = {
1255    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
1256 };
1257 static final long[] jjbitVec51 = {
1258    0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
1259 };
1260 static final long[] jjbitVec52 = {
1261    0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
1262 };
1263 static final long[] jjbitVec53 = {
1264    0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1265 };
1266 static final long[] jjbitVec54 = {
1267    0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1268 };
1269 static final long[] jjbitVec55 = {
1270    0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
1271 };
1272 static final long[] jjbitVec56 = {
1273    0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
1274 };
1275 static final long[] jjbitVec57 = {
1276    0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
1277 };
1278 static final long[] jjbitVec58 = {
1279    0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
1280 };
1281 static final long[] jjbitVec59 = {
1282    0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1283 };
1284 static final long[] jjbitVec60 = {
1285    0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1286 };
1287 static final long[] jjbitVec61 = {
1288    0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1289 };
1290 private int jjMoveNfa_0(int startState, int curPos)
1291 {
1292    int startsAt = 0;
1293    jjnewStateCnt = 65;
1294    int i = 1;
1295    jjstateSet[0] = startState;
1296    int kind = 0x7fffffff;
1297    for (;;)
1298    {
1299       if (++jjround == 0x7fffffff)
1300          ReInitRounds();
1301       if (curChar < 64)
1302       {
1303          long l = 1L << curChar;
1304          do
1305          {
1306             switch(jjstateSet[--i])
1307             {
1308                case 3:
1309                   if ((0x3ff000000000000L & l) != 0L)
1310                      jjCheckNAddStates(0, 6);
1311                   else if (curChar == 36)
1312                   {
1313                      if (kind > 137)
1314                         kind = 137;
1315                      jjCheckNAdd(32);
1316                   }
1317                   else if (curChar == 34)
1318                      jjCheckNAddStates(7, 9);
1319                   else if (curChar == 39)
1320                      jjAddStates(10, 11);
1321                   else if (curChar == 46)
1322                      jjCheckNAdd(8);
1323                   else if (curChar == 47)
1324                      jjstateSet[jjnewStateCnt++] = 2;
1325                   if ((0x3fe000000000000L & l) != 0L)
1326                   {
1327                      if (kind > 75)
1328                         kind = 75;
1329                      jjCheckNAddTwoStates(5, 6);
1330                   }
1331                   else if (curChar == 48)
1332                   {
1333                      if (kind > 75)
1334                         kind = 75;
1335                      jjCheckNAddStates(12, 16);
1336                   }
1337                   break;
1338                case 0:
1339                   if (curChar == 42)
1340                      jjstateSet[jjnewStateCnt++] = 1;
1341                   break;
1342                case 1:
1343                   if ((0xffff7fffffffffffL & l) != 0L && kind > 18)
1344                      kind = 18;
1345                   break;
1346                case 2:
1347                   if (curChar == 42)
1348                      jjstateSet[jjnewStateCnt++] = 0;
1349                   break;
1350                case 4:
1351                   if ((0x3fe000000000000L & l) == 0L)
1352                      break;
1353                   if (kind > 75)
1354                      kind = 75;
1355                   jjCheckNAddTwoStates(5, 6);
1356                   break;
1357                case 5:
1358                   if ((0x3ff000000000000L & l) == 0L)
1359                      break;
1360                   if (kind > 75)
1361                      kind = 75;
1362                   jjCheckNAddTwoStates(5, 6);
1363                   break;
1364                case 7:
1365                   if (curChar == 46)
1366                      jjCheckNAdd(8);
1367                   break;
1368                case 8:
1369                   if ((0x3ff000000000000L & l) == 0L)
1370                      break;
1371                   if (kind > 79)
1372                      kind = 79;
1373                   jjCheckNAddStates(17, 19);
1374                   break;
1375                case 10:
1376                   if ((0x280000000000L & l) != 0L)
1377                      jjCheckNAdd(11);
1378                   break;
1379                case 11:
1380                   if ((0x3ff000000000000L & l) == 0L)
1381                      break;
1382                   if (kind > 79)
1383                      kind = 79;
1384                   jjCheckNAddTwoStates(11, 12);
1385                   break;
1386                case 13:
1387                   if (curChar == 39)
1388                      jjAddStates(10, 11);
1389                   break;
1390                case 14:
1391                   if ((0xffffff7fffffdbffL & l) != 0L)
1392                      jjCheckNAdd(15);
1393                   break;
1394                case 15:
1395                   if (curChar == 39 && kind > 84)
1396                      kind = 84;
1397                   break;
1398                case 17:
1399                   if ((0x8400000000L & l) != 0L)
1400                      jjCheckNAdd(15);
1401                   break;
1402                case 18:
1403                   if ((0xff000000000000L & l) != 0L)
1404                      jjCheckNAddTwoStates(19, 15);
1405                   break;
1406                case 19:
1407                   if ((0xff000000000000L & l) != 0L)
1408                      jjCheckNAdd(15);
1409                   break;
1410                case 20:
1411                   if ((0xf000000000000L & l) != 0L)
1412                      jjstateSet[jjnewStateCnt++] = 21;
1413                   break;
1414                case 21:
1415                   if ((0xff000000000000L & l) != 0L)
1416                      jjCheckNAdd(19);
1417                   break;
1418                case 22:
1419                   if (curChar == 34)
1420                      jjCheckNAddStates(7, 9);
1421                   break;
1422                case 23:
1423                   if ((0xfffffffbffffdbffL & l) != 0L)
1424                      jjCheckNAddStates(7, 9);
1425                   break;
1426                case 25:
1427                   if ((0x8400000000L & l) != 0L)
1428                      jjCheckNAddStates(7, 9);
1429                   break;
1430                case 26:
1431                   if (curChar == 34 && kind > 85)
1432                      kind = 85;
1433                   break;
1434                case 27:
1435                   if ((0xff000000000000L & l) != 0L)
1436                      jjCheckNAddStates(20, 23);
1437                   break;
1438                case 28:
1439                   if ((0xff000000000000L & l) != 0L)
1440                      jjCheckNAddStates(7, 9);
1441                   break;
1442                case 29:
1443                   if ((0xf000000000000L & l) != 0L)
1444                      jjstateSet[jjnewStateCnt++] = 30;
1445                   break;
1446                case 30:
1447                   if ((0xff000000000000L & l) != 0L)
1448                      jjCheckNAdd(28);
1449                   break;
1450                case 31:
1451                   if (curChar != 36)
1452                      break;
1453                   if (kind > 137)
1454                      kind = 137;
1455                   jjCheckNAdd(32);
1456                   break;
1457                case 32:
1458                   if ((0x3ff00100fffc1ffL & l) == 0L)
1459                      break;
1460                   if (kind > 137)
1461                      kind = 137;
1462                   jjCheckNAdd(32);
1463                   break;
1464                case 33:
1465                   if ((0x3ff000000000000L & l) != 0L)
1466                      jjCheckNAddStates(0, 6);
1467                   break;
1468                case 34:
1469                   if ((0x3ff000000000000L & l) != 0L)
1470                      jjCheckNAddStates(24, 26);
1471                   break;
1472                case 36:
1473                   if ((0x280000000000L & l) != 0L)
1474                      jjCheckNAdd(37);
1475                   break;
1476                case 37:
1477                   if ((0x3ff000000000000L & l) != 0L)
1478                      jjCheckNAddTwoStates(37, 12);
1479                   break;
1480                case 38:
1481                   if ((0x3ff000000000000L & l) != 0L)
1482                      jjCheckNAddTwoStates(38, 39);
1483                   break;
1484                case 40:
1485                   if ((0x280000000000L & l) != 0L)
1486                      jjCheckNAdd(41);
1487                   break;
1488                case 41:
1489                   if ((0x3ff000000000000L & l) == 0L)
1490                      break;
1491                   if (kind > 79)
1492                      kind = 79;
1493                   jjCheckNAddTwoStates(41, 12);
1494                   break;
1495                case 42:
1496                   if ((0x3ff000000000000L & l) != 0L)
1497                      jjCheckNAddTwoStates(42, 43);
1498                   break;
1499                case 43:
1500                   if (curChar != 46)
1501                      break;
1502                   if (kind > 79)
1503                      kind = 79;
1504                   jjCheckNAddStates(27, 29);
1505                   break;
1506                case 44:
1507                   if ((0x3ff000000000000L & l) == 0L)
1508                      break;
1509                   if (kind > 79)
1510                      kind = 79;
1511                   jjCheckNAddStates(27, 29);
1512                   break;
1513                case 46:
1514                   if ((0x280000000000L & l) != 0L)
1515                      jjCheckNAdd(47);
1516                   break;
1517                case 47:
1518                   if ((0x3ff000000000000L & l) == 0L)
1519                      break;
1520                   if (kind > 79)
1521                      kind = 79;
1522                   jjCheckNAddTwoStates(47, 12);
1523                   break;
1524                case 48:
1525                   if (curChar != 48)
1526                      break;
1527                   if (kind > 75)
1528                      kind = 75;
1529                   jjCheckNAddStates(12, 16);
1530                   break;
1531                case 50:
1532                   if ((0x3ff000000000000L & l) == 0L)
1533                      break;
1534                   if (kind > 75)
1535                      kind = 75;
1536                   jjCheckNAddTwoStates(50, 6);
1537                   break;
1538                case 51:
1539                   if ((0xff000000000000L & l) == 0L)
1540                      break;
1541                   if (kind > 75)
1542                      kind = 75;
1543                   jjCheckNAddTwoStates(51, 6);
1544                   break;
1545                case 53:
1546                   if ((0x3ff000000000000L & l) != 0L)
1547                      jjAddStates(30, 31);
1548                   break;
1549                case 54:
1550                   if (curChar == 46)
1551                      jjCheckNAdd(55);
1552                   break;
1553                case 55:
1554                   if ((0x3ff000000000000L & l) != 0L)
1555                      jjCheckNAddTwoStates(55, 56);
1556                   break;
1557                case 57:
1558                   if ((0x280000000000L & l) != 0L)
1559                      jjCheckNAdd(58);
1560                   break;
1561                case 58:
1562                   if ((0x3ff000000000000L & l) == 0L)
1563                      break;
1564                   if (kind > 79)
1565                      kind = 79;
1566                   jjCheckNAddTwoStates(58, 12);
1567                   break;
1568                case 60:
1569                   if ((0x3ff000000000000L & l) != 0L)
1570                      jjCheckNAddStates(32, 34);
1571                   break;
1572                case 61:
1573                   if (curChar == 46)
1574                      jjCheckNAdd(62);
1575                   break;
1576                case 63:
1577                   if ((0x280000000000L & l) != 0L)
1578                      jjCheckNAdd(64);
1579                   break;
1580                case 64:
1581                   if ((0x3ff000000000000L & l) == 0L)
1582                      break;
1583                   if (kind > 79)
1584                      kind = 79;
1585                   jjCheckNAddTwoStates(64, 12);
1586                   break;
1587                default : break;
1588             }
1589          } while(i != startsAt);
1590       }
1591       else if (curChar < 128)
1592       {
1593          long l = 1L << (curChar & 077);
1594          do
1595          {
1596             switch(jjstateSet[--i])
1597             {
1598                case 3:
1599                   if ((0x7fffffe87fffffeL & l) == 0L)
1600                      break;
1601                   if (kind > 137)
1602                      kind = 137;
1603                   jjCheckNAdd(32);
1604                   break;
1605                case 1:
1606                   if (kind > 18)
1607                      kind = 18;
1608                   break;
1609                case 6:
1610                   if ((0x100000001000L & l) != 0L && kind > 75)
1611                      kind = 75;
1612                   break;
1613                case 9:
1614                   if ((0x2000000020L & l) != 0L)
1615                      jjAddStates(35, 36);
1616                   break;
1617                case 12:
1618                   if ((0x5000000050L & l) != 0L && kind > 79)
1619                      kind = 79;
1620                   break;
1621                case 14:
1622                   if ((0xffffffffefffffffL & l) != 0L)
1623                      jjCheckNAdd(15);
1624                   break;
1625                case 16:
1626                   if (curChar == 92)
1627                      jjAddStates(37, 39);
1628                   break;
1629                case 17:
1630                   if ((0x14404410000000L & l) != 0L)
1631                      jjCheckNAdd(15);
1632                   break;
1633                case 23:
1634                   if ((0xffffffffefffffffL & l) != 0L)
1635                      jjCheckNAddStates(7, 9);
1636                   break;
1637                case 24:
1638                   if (curChar == 92)
1639                      jjAddStates(40, 42);
1640                   break;
1641                case 25:
1642                   if ((0x14404410000000L & l) != 0L)
1643                      jjCheckNAddStates(7, 9);
1644                   break;
1645                case 32:
1646                   if ((0x87fffffe87fffffeL & l) == 0L)
1647                      break;
1648                   if (kind > 137)
1649                      kind = 137;
1650                   jjCheckNAdd(32);
1651                   break;
1652                case 35:
1653                   if ((0x2000000020L & l) != 0L)
1654                      jjAddStates(43, 44);
1655                   break;
1656                case 39:
1657                   if ((0x2000000020L & l) != 0L)
1658                      jjAddStates(45, 46);
1659                   break;
1660                case 45:
1661                   if ((0x2000000020L & l) != 0L)
1662                      jjAddStates(47, 48);
1663                   break;
1664                case 49:
1665                   if ((0x100000001000000L & l) != 0L)
1666                      jjCheckNAdd(50);
1667                   break;
1668                case 50:
1669                   if ((0x7e0000007eL & l) == 0L)
1670                      break;
1671                   if (kind > 75)
1672                      kind = 75;
1673                   jjCheckNAddTwoStates(50, 6);
1674                   break;
1675                case 52:
1676                   if ((0x100000001000000L & l) != 0L)
1677                      jjCheckNAddTwoStates(53, 54);
1678                   break;
1679                case 53:
1680                   if ((0x7e0000007eL & l) != 0L)
1681                      jjCheckNAddTwoStates(53, 54);
1682                   break;
1683                case 55:
1684                   if ((0x7e0000007eL & l) != 0L)
1685                      jjAddStates(49, 50);
1686                   break;
1687                case 56:
1688                   if ((0x1000000010000L & l) != 0L)
1689                      jjAddStates(51, 52);
1690                   break;
1691                case 59:
1692                   if ((0x100000001000000L & l) != 0L)
1693                      jjCheckNAdd(60);
1694                   break;
1695                case 60:
1696                   if ((0x7e0000007eL & l) != 0L)
1697                      jjCheckNAddStates(32, 34);
1698                   break;
1699                case 62:
1700                   if ((0x1000000010000L & l) != 0L)
1701                      jjAddStates(53, 54);
1702                   break;
1703                default : break;
1704             }
1705          } while(i != startsAt);
1706       }
1707       else
1708       {
1709          int hiByte = (int)(curChar >> 8);
1710          int i1 = hiByte >> 6;
1711          long l1 = 1L << (hiByte & 077);
1712          int i2 = (curChar & 0xff) >> 6;
1713          long l2 = 1L << (curChar & 077);
1714          do
1715          {
1716             switch(jjstateSet[--i])
1717             {
1718                case 3:
1719                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1720                      break;
1721                   if (kind > 137)
1722                      kind = 137;
1723                   jjCheckNAdd(32);
1724                   break;
1725                case 1:
1726                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 18)
1727                      kind = 18;
1728                   break;
1729                case 14:
1730                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1731                      jjstateSet[jjnewStateCnt++] = 15;
1732                   break;
1733                case 23:
1734                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1735                      jjAddStates(7, 9);
1736                   break;
1737                case 32:
1738                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1739                      break;
1740                   if (kind > 137)
1741                      kind = 137;
1742                   jjCheckNAdd(32);
1743                   break;
1744                default : break;
1745             }
1746          } while(i != startsAt);
1747       }
1748       if (kind != 0x7fffffff)
1749       {
1750          jjmatchedKind = kind;
1751          jjmatchedPos = curPos;
1752          kind = 0x7fffffff;
1753       }
1754       ++curPos;
1755       if ((i = jjnewStateCnt) == (startsAt = 65 - (jjnewStateCnt = startsAt)))
1756          return curPos;
1757       try { curChar = input_stream.readChar(); }
1758       catch(java.io.IOException e) { return curPos; }
1759    }
1760 }
1761 private int jjMoveStringLiteralDfa0_3()
1762 {
1763    switch(curChar)
1764    {
1765       case 42:
1766          return jjMoveStringLiteralDfa1_3(0x400000L);
1767       default :
1768          return 1;
1769    }
1770 }
1771 private int jjMoveStringLiteralDfa1_3(long active0)
1772 {
1773    try { curChar = input_stream.readChar(); }
1774    catch(java.io.IOException e) {
1775       return 1;
1776    }
1777    switch(curChar)
1778    {
1779       case 47:
1780          if ((active0 & 0x400000L) != 0L)
1781             return jjStopAtPos(1, 22);
1782          break;
1783       default :
1784          return 2;
1785    }
1786    return 2;
1787 }
1788 private int jjMoveStringLiteralDfa0_1()
1789 {
1790    return jjMoveNfa_1(0, 0);
1791 }
1792 private int jjMoveNfa_1(int startState, int curPos)
1793 {
1794    int startsAt = 0;
1795    jjnewStateCnt = 3;
1796    int i = 1;
1797    jjstateSet[0] = startState;
1798    int kind = 0x7fffffff;
1799    for (;;)
1800    {
1801       if (++jjround == 0x7fffffff)
1802          ReInitRounds();
1803       if (curChar < 64)
1804       {
1805          long l = 1L << curChar;
1806          do
1807          {
1808             switch(jjstateSet[--i])
1809             {
1810                case 0:
1811                   if ((0x2400L & l) != 0L)
1812                   {
1813                      if (kind > 20)
1814                         kind = 20;
1815                   }
1816                   if (curChar == 13)
1817                      jjstateSet[jjnewStateCnt++] = 1;
1818                   break;
1819                case 1:
1820                   if (curChar == 10 && kind > 20)
1821                      kind = 20;
1822                   break;
1823                case 2:
1824                   if (curChar == 13)
1825                      jjstateSet[jjnewStateCnt++] = 1;
1826                   break;
1827                default : break;
1828             }
1829          } while(i != startsAt);
1830       }
1831       else if (curChar < 128)
1832       {
1833          long l = 1L << (curChar & 077);
1834          do
1835          {
1836             switch(jjstateSet[--i])
1837             {
1838                default : break;
1839             }
1840          } while(i != startsAt);
1841       }
1842       else
1843       {
1844          int hiByte = (int)(curChar >> 8);
1845          int i1 = hiByte >> 6;
1846          long l1 = 1L << (hiByte & 077);
1847          int i2 = (curChar & 0xff) >> 6;
1848          long l2 = 1L << (curChar & 077);
1849          do
1850          {
1851             switch(jjstateSet[--i])
1852             {
1853                default : break;
1854             }
1855          } while(i != startsAt);
1856       }
1857       if (kind != 0x7fffffff)
1858       {
1859          jjmatchedKind = kind;
1860          jjmatchedPos = curPos;
1861          kind = 0x7fffffff;
1862       }
1863       ++curPos;
1864       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1865          return curPos;
1866       try { curChar = input_stream.readChar(); }
1867       catch(java.io.IOException e) { return curPos; }
1868    }
1869 }
1870 private int jjMoveStringLiteralDfa0_2()
1871 {
1872    switch(curChar)
1873    {
1874       case 42:
1875          return jjMoveStringLiteralDfa1_2(0x200000L);
1876       default :
1877          return 1;
1878    }
1879 }
1880 private int jjMoveStringLiteralDfa1_2(long active0)
1881 {
1882    try { curChar = input_stream.readChar(); }
1883    catch(java.io.IOException e) {
1884       return 1;
1885    }
1886    switch(curChar)
1887    {
1888       case 47:
1889          if ((active0 & 0x200000L) != 0L)
1890             return jjStopAtPos(1, 21);
1891          break;
1892       default :
1893          return 2;
1894    }
1895    return 2;
1896 }
1897 static final int[] jjnextStates = {
1898    34, 35, 12, 38, 39, 42, 43, 23, 24, 26, 14, 16, 49, 51, 6, 52, 
1899    59, 8, 9, 12, 23, 24, 28, 26, 34, 35, 12, 44, 45, 12, 53, 54, 
1900    60, 61, 62, 10, 11, 17, 18, 20, 25, 27, 29, 36, 37, 40, 41, 46, 
1901    47, 55, 56, 57, 58, 63, 64, 
1902 };
1903 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1904 {
1905    switch(hiByte)
1906    {
1907       case 0:
1908          return ((jjbitVec2[i2] & l2) != 0L);
1909       default :
1910          if ((jjbitVec0[i1] & l1) != 0L)
1911             return true;
1912          return false;
1913    }
1914 }
1915 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1916 {
1917    switch(hiByte)
1918    {
1919       case 0:
1920          return ((jjbitVec4[i2] & l2) != 0L);
1921       case 2:
1922          return ((jjbitVec5[i2] & l2) != 0L);
1923       case 3:
1924          return ((jjbitVec6[i2] & l2) != 0L);
1925       case 4:
1926          return ((jjbitVec7[i2] & l2) != 0L);
1927       case 5:
1928          return ((jjbitVec8[i2] & l2) != 0L);
1929       case 6:
1930          return ((jjbitVec9[i2] & l2) != 0L);
1931       case 7:
1932          return ((jjbitVec10[i2] & l2) != 0L);
1933       case 9:
1934          return ((jjbitVec11[i2] & l2) != 0L);
1935       case 10:
1936          return ((jjbitVec12[i2] & l2) != 0L);
1937       case 11:
1938          return ((jjbitVec13[i2] & l2) != 0L);
1939       case 12:
1940          return ((jjbitVec14[i2] & l2) != 0L);
1941       case 13:
1942          return ((jjbitVec15[i2] & l2) != 0L);
1943       case 14:
1944          return ((jjbitVec16[i2] & l2) != 0L);
1945       case 15:
1946          return ((jjbitVec17[i2] & l2) != 0L);
1947       case 16:
1948          return ((jjbitVec18[i2] & l2) != 0L);
1949       case 17:
1950          return ((jjbitVec19[i2] & l2) != 0L);
1951       case 18:
1952          return ((jjbitVec20[i2] & l2) != 0L);
1953       case 19:
1954          return ((jjbitVec21[i2] & l2) != 0L);
1955       case 20:
1956          return ((jjbitVec0[i2] & l2) != 0L);
1957       case 22:
1958          return ((jjbitVec22[i2] & l2) != 0L);
1959       case 23:
1960          return ((jjbitVec23[i2] & l2) != 0L);
1961       case 24:
1962          return ((jjbitVec24[i2] & l2) != 0L);
1963       case 30:
1964          return ((jjbitVec25[i2] & l2) != 0L);
1965       case 31:
1966          return ((jjbitVec26[i2] & l2) != 0L);
1967       case 32:
1968          return ((jjbitVec27[i2] & l2) != 0L);
1969       case 33:
1970          return ((jjbitVec28[i2] & l2) != 0L);
1971       case 48:
1972          return ((jjbitVec29[i2] & l2) != 0L);
1973       case 49:
1974          return ((jjbitVec30[i2] & l2) != 0L);
1975       case 77:
1976          return ((jjbitVec31[i2] & l2) != 0L);
1977       case 159:
1978          return ((jjbitVec32[i2] & l2) != 0L);
1979       case 164:
1980          return ((jjbitVec33[i2] & l2) != 0L);
1981       case 215:
1982          return ((jjbitVec34[i2] & l2) != 0L);
1983       case 250:
1984          return ((jjbitVec35[i2] & l2) != 0L);
1985       case 251:
1986          return ((jjbitVec36[i2] & l2) != 0L);
1987       case 253:
1988          return ((jjbitVec37[i2] & l2) != 0L);
1989       case 254:
1990          return ((jjbitVec38[i2] & l2) != 0L);
1991       case 255:
1992          return ((jjbitVec39[i2] & l2) != 0L);
1993       default :
1994          if ((jjbitVec3[i1] & l1) != 0L)
1995             return true;
1996          return false;
1997    }
1998 }
1999 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
2000 {
2001    switch(hiByte)
2002    {
2003       case 0:
2004          return ((jjbitVec40[i2] & l2) != 0L);
2005       case 2:
2006          return ((jjbitVec5[i2] & l2) != 0L);
2007       case 3:
2008          return ((jjbitVec41[i2] & l2) != 0L);
2009       case 4:
2010          return ((jjbitVec42[i2] & l2) != 0L);
2011       case 5:
2012          return ((jjbitVec43[i2] & l2) != 0L);
2013       case 6:
2014          return ((jjbitVec44[i2] & l2) != 0L);
2015       case 7:
2016          return ((jjbitVec45[i2] & l2) != 0L);
2017       case 9:
2018          return ((jjbitVec46[i2] & l2) != 0L);
2019       case 10:
2020          return ((jjbitVec47[i2] & l2) != 0L);
2021       case 11:
2022          return ((jjbitVec48[i2] & l2) != 0L);
2023       case 12:
2024          return ((jjbitVec49[i2] & l2) != 0L);
2025       case 13:
2026          return ((jjbitVec50[i2] & l2) != 0L);
2027       case 14:
2028          return ((jjbitVec51[i2] & l2) != 0L);
2029       case 15:
2030          return ((jjbitVec52[i2] & l2) != 0L);
2031       case 16:
2032          return ((jjbitVec53[i2] & l2) != 0L);
2033       case 17:
2034          return ((jjbitVec19[i2] & l2) != 0L);
2035       case 18:
2036          return ((jjbitVec20[i2] & l2) != 0L);
2037       case 19:
2038          return ((jjbitVec54[i2] & l2) != 0L);
2039       case 20:
2040          return ((jjbitVec0[i2] & l2) != 0L);
2041       case 22:
2042          return ((jjbitVec22[i2] & l2) != 0L);
2043       case 23:
2044          return ((jjbitVec55[i2] & l2) != 0L);
2045       case 24:
2046          return ((jjbitVec56[i2] & l2) != 0L);
2047       case 30:
2048          return ((jjbitVec25[i2] & l2) != 0L);
2049       case 31:
2050          return ((jjbitVec26[i2] & l2) != 0L);
2051       case 32:
2052          return ((jjbitVec57[i2] & l2) != 0L);
2053       case 33:
2054          return ((jjbitVec28[i2] & l2) != 0L);
2055       case 48:
2056          return ((jjbitVec58[i2] & l2) != 0L);
2057       case 49:
2058          return ((jjbitVec30[i2] & l2) != 0L);
2059       case 77:
2060          return ((jjbitVec31[i2] & l2) != 0L);
2061       case 159:
2062          return ((jjbitVec32[i2] & l2) != 0L);
2063       case 164:
2064          return ((jjbitVec33[i2] & l2) != 0L);
2065       case 215:
2066          return ((jjbitVec34[i2] & l2) != 0L);
2067       case 250:
2068          return ((jjbitVec35[i2] & l2) != 0L);
2069       case 251:
2070          return ((jjbitVec59[i2] & l2) != 0L);
2071       case 253:
2072          return ((jjbitVec37[i2] & l2) != 0L);
2073       case 254:
2074          return ((jjbitVec60[i2] & l2) != 0L);
2075       case 255:
2076          return ((jjbitVec61[i2] & l2) != 0L);
2077       default :
2078          if ((jjbitVec3[i1] & l1) != 0L)
2079             return true;
2080          return false;
2081    }
2082 }
2083 
2084 /** Token literal values. */
2085 public static final String[] jjstrLiteralImages = {
2086 "", "\114\117\117\113\101\110\105\101\104", 
2087 "\111\107\116\117\122\105\137\103\101\123\105", "\120\101\122\123\105\122\137\102\105\107\111\116", 
2088 "\120\101\122\123\105\122\137\105\116\104", "\112\101\126\101\103\117\104\105", "\124\117\113\105\116", 
2089 "\123\120\105\103\111\101\114\137\124\117\113\105\116", "\115\117\122\105", "\123\113\111\120", 
2090 "\124\117\113\105\116\137\115\107\122\137\104\105\103\114\123", "\105\117\106", null, null, null, null, null, null, null, null, null, null, 
2091 null, null, "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", 
2092 "\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", 
2093 "\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164", 
2094 "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145", 
2095 "\145\154\163\145", "\145\170\164\145\156\144\163", "\146\141\154\163\145", 
2096 "\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", 
2097 "\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163", 
2098 "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164", 
2099 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167", 
2100 "\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145", 
2101 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156", 
2102 "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", 
2103 "\163\165\160\145\162", "\163\167\151\164\143\150", 
2104 "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163", 
2105 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144", 
2106 "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, 
2107 null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", 
2108 "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", 
2109 "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", 
2110 "\174", "\136", "\45", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", 
2111 "\136\75", "\45\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\43", 
2112 "\145\156\165\155", "\74\74\75", "\76\76\75", "\76\76\76\75", "\74\74", 
2113 "\141\163\163\145\162\164", null, null, null, };
2114 
2115 /** Lexer state names. */
2116 public static final String[] lexStateNames = {
2117    "DEFAULT",
2118    "IN_SINGLE_LINE_COMMENT",
2119    "IN_FORMAL_COMMENT",
2120    "IN_MULTI_LINE_COMMENT",
2121 };
2122 
2123 /** Lex State array. */
2124 public static final int[] jjnewLexState = {
2125    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, 
2126    -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, 
2127    -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, 
2128    -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, 
2129    -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, 
2130    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
2131 };
2132 static final long[] jjtoToken = {
2133    0xffffffffff000fffL, 0xfffffffffff08fffL, 0x3ffL, 
2134 };
2135 static final long[] jjtoSkip = {
2136    0x71f000L, 0x0L, 0x0L, 
2137 };
2138 static final long[] jjtoSpecial = {
2139    0x71f000L, 0x0L, 0x0L, 
2140 };
2141 static final long[] jjtoMore = {
2142    0x8e0000L, 0x0L, 0x0L, 
2143 };
2144 protected JavaCharStream input_stream;
2145 private final int[] jjrounds = new int[65];
2146 private final int[] jjstateSet = new int[130];
2147 private final StringBuilder jjimage = new StringBuilder();
2148 private StringBuilder image = jjimage;
2149 private int jjimageLen;
2150 private int lengthOfMatch;
2151 protected char curChar;
2152 /** Constructor. */
2153 public JJTreeParserTokenManager(JavaCharStream stream){
2154    if (JavaCharStream.staticFlag)
2155       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2156    input_stream = stream;
2157 }
2158 
2159 /** Constructor. */
2160 public JJTreeParserTokenManager(JavaCharStream stream, int lexState){
2161    this(stream);
2162    SwitchTo(lexState);
2163 }
2164 
2165 /** Reinitialise parser. */
2166 public void ReInit(JavaCharStream stream)
2167 {
2168    jjmatchedPos = jjnewStateCnt = 0;
2169    curLexState = defaultLexState;
2170    input_stream = stream;
2171    ReInitRounds();
2172 }
2173 private void ReInitRounds()
2174 {
2175    int i;
2176    jjround = 0x80000001;
2177    for (i = 65; i-- > 0;)
2178       jjrounds[i] = 0x80000000;
2179 }
2180 
2181 /** Reinitialise parser. */
2182 public void ReInit(JavaCharStream stream, int lexState)
2183 {
2184    ReInit(stream);
2185    SwitchTo(lexState);
2186 }
2187 
2188 /** Switch to specified lex state. */
2189 public void SwitchTo(int lexState)
2190 {
2191    if (lexState >= 4 || lexState < 0)
2192       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2193    else
2194       curLexState = lexState;
2195 }
2196 
2197 protected Token jjFillToken()
2198 {
2199    final Token t;
2200    final String curTokenImage;
2201    final int beginLine;
2202    final int endLine;
2203    final int beginColumn;
2204    final int endColumn;
2205    String im = jjstrLiteralImages[jjmatchedKind];
2206    curTokenImage = (im == null) ? input_stream.GetImage() : im;
2207    beginLine = input_stream.getBeginLine();
2208    beginColumn = input_stream.getBeginColumn();
2209    endLine = input_stream.getEndLine();
2210    endColumn = input_stream.getEndColumn();
2211    t = Token.newToken(jjmatchedKind, curTokenImage);
2212 
2213    t.beginLine = beginLine;
2214    t.endLine = endLine;
2215    t.beginColumn = beginColumn;
2216    t.endColumn = endColumn;
2217 
2218    return t;
2219 }
2220 
2221 int curLexState = 0;
2222 int defaultLexState = 0;
2223 int jjnewStateCnt;
2224 int jjround;
2225 int jjmatchedPos;
2226 int jjmatchedKind;
2227 
2228 /** Get the next Token. */
2229 public Token getNextToken() 
2230 {
2231   Token specialToken = null;
2232   Token matchedToken;
2233   int curPos = 0;
2234 
2235   EOFLoop :
2236   for (;;)
2237   {
2238    try
2239    {
2240       curChar = input_stream.BeginToken();
2241    }
2242    catch(java.io.IOException e)
2243    {
2244       jjmatchedKind = 0;
2245       matchedToken = jjFillToken();
2246       matchedToken.specialToken = specialToken;
2247       return matchedToken;
2248    }
2249    image = jjimage;
2250    image.setLength(0);
2251    jjimageLen = 0;
2252 
2253    for (;;)
2254    {
2255      switch(curLexState)
2256      {
2257        case 0:
2258          jjmatchedKind = 0x7fffffff;
2259          jjmatchedPos = 0;
2260          curPos = jjMoveStringLiteralDfa0_0();
2261          break;
2262        case 1:
2263          jjmatchedKind = 0x7fffffff;
2264          jjmatchedPos = 0;
2265          curPos = jjMoveStringLiteralDfa0_1();
2266          if (jjmatchedPos == 0 && jjmatchedKind > 23)
2267          {
2268             jjmatchedKind = 23;
2269          }
2270          break;
2271        case 2:
2272          jjmatchedKind = 0x7fffffff;
2273          jjmatchedPos = 0;
2274          curPos = jjMoveStringLiteralDfa0_2();
2275          if (jjmatchedPos == 0 && jjmatchedKind > 23)
2276          {
2277             jjmatchedKind = 23;
2278          }
2279          break;
2280        case 3:
2281          jjmatchedKind = 0x7fffffff;
2282          jjmatchedPos = 0;
2283          curPos = jjMoveStringLiteralDfa0_3();
2284          if (jjmatchedPos == 0 && jjmatchedKind > 23)
2285          {
2286             jjmatchedKind = 23;
2287          }
2288          break;
2289      }
2290      if (jjmatchedKind != 0x7fffffff)
2291      {
2292         if (jjmatchedPos + 1 < curPos)
2293            input_stream.backup(curPos - jjmatchedPos - 1);
2294         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2295         {
2296            matchedToken = jjFillToken();
2297            matchedToken.specialToken = specialToken;
2298            TokenLexicalActions(matchedToken);
2299        if (jjnewLexState[jjmatchedKind] != -1)
2300          curLexState = jjnewLexState[jjmatchedKind];
2301            return matchedToken;
2302         }
2303         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2304         {
2305            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2306            {
2307               matchedToken = jjFillToken();
2308               if (specialToken == null)
2309                  specialToken = matchedToken;
2310               else
2311               {
2312                  matchedToken.specialToken = specialToken;
2313                  specialToken = (specialToken.next = matchedToken);
2314               }
2315               SkipLexicalActions(matchedToken);
2316            }
2317            else
2318               SkipLexicalActions(null);
2319          if (jjnewLexState[jjmatchedKind] != -1)
2320            curLexState = jjnewLexState[jjmatchedKind];
2321            continue EOFLoop;
2322         }
2323         MoreLexicalActions();
2324       if (jjnewLexState[jjmatchedKind] != -1)
2325         curLexState = jjnewLexState[jjmatchedKind];
2326         curPos = 0;
2327         jjmatchedKind = 0x7fffffff;
2328         try {
2329            curChar = input_stream.readChar();
2330            continue;
2331         }
2332         catch (java.io.IOException e1) { }
2333      }
2334      int error_line = input_stream.getEndLine();
2335      int error_column = input_stream.getEndColumn();
2336      String error_after = null;
2337      boolean EOFSeen = false;
2338      try { input_stream.readChar(); input_stream.backup(1); }
2339      catch (java.io.IOException e1) {
2340         EOFSeen = true;
2341         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2342         if (curChar == '\n' || curChar == '\r') {
2343            error_line++;
2344            error_column = 0;
2345         }
2346         else
2347            error_column++;
2348      }
2349      if (!EOFSeen) {
2350         input_stream.backup(1);
2351         error_after = curPos <= 1 ? "" : input_stream.GetImage();
2352      }
2353      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2354    }
2355   }
2356 }
2357 
2358 void SkipLexicalActions(Token matchedToken)
2359 {
2360    switch(jjmatchedKind)
2361    {
2362       default :
2363          break;
2364    }
2365 }
2366 void MoreLexicalActions()
2367 {
2368    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2369    switch(jjmatchedKind)
2370    {
2371       case 18 :
2372          image.append(input_stream.GetSuffix(jjimageLen));
2373          jjimageLen = 0;
2374                    input_stream.backup(1);
2375          break;
2376       default :
2377          break;
2378    }
2379 }
2380 void TokenLexicalActions(Token matchedToken)
2381 {
2382    switch(jjmatchedKind)
2383    {
2384       case 127 :
2385         image.append(jjstrLiteralImages[127]);
2386         lengthOfMatch = jjstrLiteralImages[127].length();
2387      matchedToken.kind = GT;
2388      matchedToken.realKind = RUNSIGNEDSHIFT;
2389      input_stream.backup(2);
2390      matchedToken.image = ">";
2391          break;
2392       case 128 :
2393         image.append(jjstrLiteralImages[128]);
2394         lengthOfMatch = jjstrLiteralImages[128].length();
2395      matchedToken.kind = GT;
2396      matchedToken.realKind = RSIGNEDSHIFT;
2397      input_stream.backup(1);
2398      matchedToken.image = ">";
2399          break;
2400       default :
2401          break;
2402    }
2403 }
2404 private void jjCheckNAdd(int state)
2405 {
2406    if (jjrounds[state] != jjround)
2407    {
2408       jjstateSet[jjnewStateCnt++] = state;
2409       jjrounds[state] = jjround;
2410    }
2411 }
2412 private void jjAddStates(int start, int end)
2413 {
2414    do {
2415       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2416    } while (start++ != end);
2417 }
2418 private void jjCheckNAddTwoStates(int state1, int state2)
2419 {
2420    jjCheckNAdd(state1);
2421    jjCheckNAdd(state2);
2422 }
2423 
2424 private void jjCheckNAddStates(int start, int end)
2425 {
2426    do {
2427       jjCheckNAdd(jjnextStates[start]);
2428    } while (start++ != end);
2429 }
2430 
2431 }