ParseCpslTokenManager.java
0001 /* ParseCpslTokenManager.java */
0002 /* Generated By:JavaCC: Do not edit this line. ParseCpslTokenManager.java */
0003 package gate.jape.parser;
0004 import java.io.*;
0005 import java.net.*;
0006 import java.util.*;
0007 import java.util.regex.*;
0008 import java.lang.reflect.Constructor;
0009 import java.lang.reflect.InvocationTargetException;
0010 import gate.Factory;
0011 import gate.util.*;
0012 import gate.jape.*;
0013 import gate.jape.constraint.*;
0014 import gate.event.*;
0015 import org.apache.log4j.Logger;
0016 
0017 /** Token Manager. */
0018 @SuppressWarnings("unused")public class ParseCpslTokenManager implements ParseCpslConstants {
0019 
0020   /** Debug output. */
0021   public  java.io.PrintStream debugStream = System.out;
0022   /** Set debug output. */
0023   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
0024 private int jjStopAtPos(int pos, int kind)
0025 {
0026    jjmatchedKind = kind;
0027    jjmatchedPos = pos;
0028    return pos + 1;
0029 }
0030 private int jjMoveStringLiteralDfa0_0(){
0031    switch(curChar)
0032    {
0033       case 33:
0034          jjmatchedKind = 31;
0035          return jjMoveNfa_0(00);
0036       case 34:
0037          jjmatchedKind = 36;
0038          return jjMoveNfa_0(00);
0039       case 40:
0040          jjmatchedKind = 59;
0041          return jjMoveNfa_0(00);
0042       case 41:
0043          jjmatchedKind = 60;
0044          return jjMoveNfa_0(00);
0045       case 44:
0046          jjmatchedKind = 56;
0047          return jjMoveNfa_0(00);
0048       case 45:
0049          return jjMoveStringLiteralDfa1_0(0x0L0x100L);
0050       case 46:
0051          jjmatchedKind = 54;
0052          return jjMoveNfa_0(00);
0053       case 58:
0054          jjmatchedKind = 52;
0055          return jjMoveStringLiteralDfa1_0(0x0L0x1L);
0056       case 59:
0057          jjmatchedKind = 53;
0058          return jjMoveNfa_0(00);
0059       case 61:
0060          jjmatchedKind = 63;
0061          return jjMoveNfa_0(00);
0062       case 64:
0063          jjmatchedKind = 34;
0064          return jjMoveNfa_0(00);
0065       case 67:
0066          return jjMoveStringLiteralDfa1_0(0xe00000L0x0L);
0067       case 73:
0068          return jjMoveStringLiteralDfa1_0(0x2100000L0x0L);
0069       case 77:
0070          return jjMoveStringLiteralDfa1_0(0x10000800L0x0L);
0071       case 79:
0072          return jjMoveStringLiteralDfa1_0(0x4000000L0x0L);
0073       case 80:
0074          return jjMoveStringLiteralDfa1_0(0x41001000L0x0L);
0075       case 82:
0076          return jjMoveStringLiteralDfa1_0(0x8000000L0x0L);
0077       case 84:
0078          return jjMoveStringLiteralDfa1_0(0x20000000L0x0L);
0079       case 91:
0080          jjmatchedKind = 61;
0081          return jjMoveNfa_0(00);
0082       case 93:
0083          jjmatchedKind = 62;
0084          return jjMoveNfa_0(00);
0085       case 99:
0086          return jjMoveStringLiteralDfa1_0(0xe00000L0x0L);
0087       case 105:
0088          return jjMoveStringLiteralDfa1_0(0x2100000L0x0L);
0089       case 109:
0090          return jjMoveStringLiteralDfa1_0(0x10000800L0x0L);
0091       case 111:
0092          return jjMoveStringLiteralDfa1_0(0x4000000L0x0L);
0093       case 112:
0094          return jjMoveStringLiteralDfa1_0(0x41001000L0x0L);
0095       case 114:
0096          return jjMoveStringLiteralDfa1_0(0x8000000L0x0L);
0097       case 116:
0098          return jjMoveStringLiteralDfa1_0(0x20000000L0x0L);
0099       case 123:
0100          jjmatchedKind = 57;
0101          return jjMoveNfa_0(00);
0102       case 124:
0103          jjmatchedKind = 55;
0104          return jjMoveNfa_0(00);
0105       case 125:
0106          jjmatchedKind = 58;
0107          return jjMoveNfa_0(00);
0108       default :
0109          return jjMoveNfa_0(00);
0110    }
0111 }
0112 private int jjMoveStringLiteralDfa1_0(long active0, long active1){
0113    try curChar = input_stream.readChar()}
0114    catch(java.io.IOException e) {
0115    return jjMoveNfa_0(00);
0116    }
0117    switch(curChar)
0118    {
0119       case 43:
0120          if ((active1 & 0x1L!= 0L)
0121          {
0122             jjmatchedKind = 64;
0123             jjmatchedPos = 1;
0124          }
0125          break;
0126       case 45:
0127          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x100L);
0128       case 65:
0129          return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
0130       case 69:
0131          return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
0132       case 72:
0133          return jjMoveStringLiteralDfa2_0(active0, 0x1001000L, active1, 0L);
0134       case 77:
0135          return jjMoveStringLiteralDfa2_0(active0, 0x100000L, active1, 0L);
0136       case 78:
0137          return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
0138       case 79:
0139          return jjMoveStringLiteralDfa2_0(active0, 0xe00000L, active1, 0L);
0140       case 80:
0141          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
0142       case 82:
0143          return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
0144       case 85:
0145          return jjMoveStringLiteralDfa2_0(active0, 0x8000800L, active1, 0L);
0146       case 97:
0147          return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
0148       case 101:
0149          return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
0150       case 104:
0151          return jjMoveStringLiteralDfa2_0(active0, 0x1001000L, active1, 0L);
0152       case 109:
0153          return jjMoveStringLiteralDfa2_0(active0, 0x100000L, active1, 0L);
0154       case 110:
0155          return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
0156       case 111:
0157          return jjMoveStringLiteralDfa2_0(active0, 0xe00000L, active1, 0L);
0158       case 112:
0159          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
0160       case 114:
0161          return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
0162       case 117:
0163          return jjMoveStringLiteralDfa2_0(active0, 0x8000800L, active1, 0L);
0164       default :
0165          break;
0166    }
0167    return jjMoveNfa_0(01);
0168 }
0169 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1){
0170    if (((active0 &= old0(active1 &= old1)) == 0L)
0171       return jjMoveNfa_0(01);
0172    try curChar = input_stream.readChar()}
0173    catch(java.io.IOException e) {
0174    return jjMoveNfa_0(01);
0175    }
0176    switch(curChar)
0177    {
0178       case 62:
0179          if ((active1 & 0x100L!= 0L)
0180          {
0181             jjmatchedKind = 72;
0182             jjmatchedPos = 2;
0183          }
0184          break;
0185       case 65:
0186          return jjMoveStringLiteralDfa3_0(active0, 0x1001000L, active1, 0L);
0187       case 67:
0188          return jjMoveStringLiteralDfa3_0(active0, 0x10000000L, active1, 0L);
0189       case 73:
0190          return jjMoveStringLiteralDfa3_0(active0, 0x40000000L, active1, 0L);
0191       case 76:
0192          return jjMoveStringLiteralDfa3_0(active0, 0x8000800L, active1, 0L);
0193       case 77:
0194          return jjMoveStringLiteralDfa3_0(active0, 0x20000000L, active1, 0L);
0195       case 78:
0196          return jjMoveStringLiteralDfa3_0(active0, 0xe00000L, active1, 0L);
0197       case 80:
0198          return jjMoveStringLiteralDfa3_0(active0, 0x2100000L, active1, 0L);
0199       case 84:
0200          return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L);
0201       case 97:
0202          return jjMoveStringLiteralDfa3_0(active0, 0x1001000L, active1, 0L);
0203       case 99:
0204          return jjMoveStringLiteralDfa3_0(active0, 0x10000000L, active1, 0L);
0205       case 105:
0206          return jjMoveStringLiteralDfa3_0(active0, 0x40000000L, active1, 0L);
0207       case 108:
0208          return jjMoveStringLiteralDfa3_0(active0, 0x8000800L, active1, 0L);
0209       case 109:
0210          return jjMoveStringLiteralDfa3_0(active0, 0x20000000L, active1, 0L);
0211       case 110:
0212          return jjMoveStringLiteralDfa3_0(active0, 0xe00000L, active1, 0L);
0213       case 112:
0214          return jjMoveStringLiteralDfa3_0(active0, 0x2100000L, active1, 0L);
0215       case 116:
0216          return jjMoveStringLiteralDfa3_0(active0, 0x4000000L, active1, 0L);
0217       default :
0218          break;
0219    }
0220    return jjMoveNfa_0(02);
0221 }
0222 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1){
0223    if (((active0 &= old0(active1 &= old1)) == 0L)
0224       return jjMoveNfa_0(02);
0225    try curChar = input_stream.readChar()}
0226    catch(java.io.IOException e) {
0227    return jjMoveNfa_0(02);
0228    }
0229    switch(curChar)
0230    {
0231       case 69:
0232          return jjMoveStringLiteralDfa4_0(active0, 0x8000000L);
0233       case 73:
0234          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
0235       case 79:
0236          return jjMoveStringLiteralDfa4_0(active0, 0x40100000L);
0237       case 80:
0238          return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
0239       case 82:
0240          return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
0241       case 83:
0242          return jjMoveStringLiteralDfa4_0(active0, 0x1001000L);
0243       case 84:
0244          return jjMoveStringLiteralDfa4_0(active0, 0xe00800L);
0245       case 85:
0246          return jjMoveStringLiteralDfa4_0(active0, 0x2000000L);
0247       case 101:
0248          return jjMoveStringLiteralDfa4_0(active0, 0x8000000L);
0249       case 105:
0250          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
0251       case 111:
0252          return jjMoveStringLiteralDfa4_0(active0, 0x40100000L);
0253       case 112:
0254          return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
0255       case 114:
0256          return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
0257       case 115:
0258          return jjMoveStringLiteralDfa4_0(active0, 0x1001000L);
0259       case 116:
0260          return jjMoveStringLiteralDfa4_0(active0, 0xe00800L);
0261       case 117:
0262          return jjMoveStringLiteralDfa4_0(active0, 0x2000000L);
0263       default :
0264          break;
0265    }
0266    return jjMoveNfa_0(03);
0267 }
0268 private int jjMoveStringLiteralDfa4_0(long old0, long active0){
0269    if (((active0 &= old0)) == 0L)
0270       return jjMoveNfa_0(03);
0271    try curChar = input_stream.readChar()}
0272    catch(java.io.IOException e) {
0273    return jjMoveNfa_0(03);
0274    }
0275    switch(curChar)
0276    {
0277       case 58:
0278          if ((active0 & 0x8000000L!= 0L)
0279          {
0280             jjmatchedKind = 27;
0281             jjmatchedPos = 4;
0282          }
0283          break;
0284       case 69:
0285          return jjMoveStringLiteralDfa5_0(active0, 0x1001000L);
0286       case 73:
0287          return jjMoveStringLiteralDfa5_0(active0, 0x800L);
0288       case 76:
0289          return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
0290       case 79:
0291          return jjMoveStringLiteralDfa5_0(active0, 0x14000000L);
0292       case 82:
0293          return jjMoveStringLiteralDfa5_0(active0, 0x40f00000L);
0294       case 84:
0295          return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
0296       case 101:
0297          return jjMoveStringLiteralDfa5_0(active0, 0x1001000L);
0298       case 105:
0299          return jjMoveStringLiteralDfa5_0(active0, 0x800L);
0300       case 108:
0301          return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
0302       case 111:
0303          return jjMoveStringLiteralDfa5_0(active0, 0x14000000L);
0304       case 114:
0305          return jjMoveStringLiteralDfa5_0(active0, 0x40f00000L);
0306       case 116:
0307          return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);
0308       default :
0309          break;
0310    }
0311    return jjMoveNfa_0(04);
0312 }
0313 private int jjMoveStringLiteralDfa5_0(long old0, long active0){
0314    if (((active0 &= old0)) == 0L)
0315       return jjMoveNfa_0(04);
0316    try curChar = input_stream.readChar()}
0317    catch(java.io.IOException e) {
0318    return jjMoveNfa_0(04);
0319    }
0320    switch(curChar)
0321    {
0322       case 58:
0323          if ((active0 & 0x1000000L!= 0L)
0324          {
0325             jjmatchedKind = 24;
0326             jjmatchedPos = 5;
0327          }
0328          else if ((active0 & 0x2000000L!= 0L)
0329          {
0330             jjmatchedKind = 25;
0331             jjmatchedPos = 5;
0332          }
0333          else if ((active0 & 0x10000000L!= 0L)
0334          {
0335             jjmatchedKind = 28;
0336             jjmatchedPos = 5;
0337          }
0338          break;
0339       case 65:
0340          return jjMoveStringLiteralDfa6_0(active0, 0x20000000L);
0341       case 73:
0342          return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
0343       case 78:
0344          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0345       case 79:
0346          return jjMoveStringLiteralDfa6_0(active0, 0xe00000L);
0347       case 80:
0348          return jjMoveStringLiteralDfa6_0(active0, 0x800L);
0349       case 83:
0350          return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
0351       case 84:
0352          return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
0353       case 97:
0354          return jjMoveStringLiteralDfa6_0(active0, 0x20000000L);
0355       case 105:
0356          return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
0357       case 110:
0358          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
0359       case 111:
0360          return jjMoveStringLiteralDfa6_0(active0, 0xe00000L);
0361       case 112:
0362          return jjMoveStringLiteralDfa6_0(active0, 0x800L);
0363       case 115:
0364          return jjMoveStringLiteralDfa6_0(active0, 0x1000L);
0365       case 116:
0366          return jjMoveStringLiteralDfa6_0(active0, 0x100000L);
0367       default :
0368          break;
0369    }
0370    return jjMoveNfa_0(05);
0371 }
0372 private int jjMoveStringLiteralDfa6_0(long old0, long active0){
0373    if (((active0 &= old0)) == 0L)
0374       return jjMoveNfa_0(05);
0375    try curChar = input_stream.readChar()}
0376    catch(java.io.IOException e) {
0377    return jjMoveNfa_0(05);
0378    }
0379    switch(curChar)
0380    {
0381       case 58:
0382          if ((active0 & 0x1000L!= 0L)
0383          {
0384             jjmatchedKind = 12;
0385             jjmatchedPos = 6;
0386          }
0387          break;
0388       case 72:
0389          return jjMoveStringLiteralDfa7_0(active0, 0x800L);
0390       case 76:
0391          return jjMoveStringLiteralDfa7_0(active0, 0xe00000L);
0392       case 83:
0393          return jjMoveStringLiteralDfa7_0(active0, 0x4100000L);
0394       case 84:
0395          return jjMoveStringLiteralDfa7_0(active0, 0x60000000L);
0396       case 104:
0397          return jjMoveStringLiteralDfa7_0(active0, 0x800L);
0398       case 108:
0399          return jjMoveStringLiteralDfa7_0(active0, 0xe00000L);
0400       case 115:
0401          return jjMoveStringLiteralDfa7_0(active0, 0x4100000L);
0402       case 116:
0403          return jjMoveStringLiteralDfa7_0(active0, 0x60000000L);
0404       default :
0405          break;
0406    }
0407    return jjMoveNfa_0(06);
0408 }
0409 private int jjMoveStringLiteralDfa7_0(long old0, long active0){
0410    if (((active0 &= old0)) == 0L)
0411       return jjMoveNfa_0(06);
0412    try curChar = input_stream.readChar()}
0413    catch(java.io.IOException e) {
0414    return jjMoveNfa_0(06);
0415    }
0416    switch(curChar)
0417    {
0418       case 58:
0419          if ((active0 & 0x100000L!= 0L)
0420          {
0421             jjmatchedKind = 20;
0422             jjmatchedPos = 7;
0423          }
0424          else if ((active0 & 0x4000000L!= 0L)
0425          {
0426             jjmatchedKind = 26;
0427             jjmatchedPos = 7;
0428          }
0429          break;
0430       case 65:
0431          return jjMoveStringLiteralDfa8_0(active0, 0x800L);
0432       case 69:
0433          return jjMoveStringLiteralDfa8_0(active0, 0x20000000L);
0434       case 76:
0435          return jjMoveStringLiteralDfa8_0(active0, 0xe00000L);
0436       case 89:
0437          return jjMoveStringLiteralDfa8_0(active0, 0x40000000L);
0438       case 97:
0439          return jjMoveStringLiteralDfa8_0(active0, 0x800L);
0440       case 101:
0441          return jjMoveStringLiteralDfa8_0(active0, 0x20000000L);
0442       case 108:
0443          return jjMoveStringLiteralDfa8_0(active0, 0xe00000L);
0444       case 121:
0445          return jjMoveStringLiteralDfa8_0(active0, 0x40000000L);
0446       default :
0447          break;
0448    }
0449    return jjMoveNfa_0(07);
0450 }
0451 private int jjMoveStringLiteralDfa8_0(long old0, long active0){
0452    if (((active0 &= old0)) == 0L)
0453       return jjMoveNfa_0(07);
0454    try curChar = input_stream.readChar()}
0455    catch(java.io.IOException e) {
0456    return jjMoveNfa_0(07);
0457    }
0458    switch(curChar)
0459    {
0460       case 58:
0461          if ((active0 & 0x20000000L!= 0L)
0462          {
0463             jjmatchedKind = 29;
0464             jjmatchedPos = 8;
0465          }
0466          else if ((active0 & 0x40000000L!= 0L)
0467          {
0468             jjmatchedKind = 30;
0469             jjmatchedPos = 8;
0470          }
0471          break;
0472       case 69:
0473          return jjMoveStringLiteralDfa9_0(active0, 0xe00000L);
0474       case 83:
0475          return jjMoveStringLiteralDfa9_0(active0, 0x800L);
0476       case 101:
0477          return jjMoveStringLiteralDfa9_0(active0, 0xe00000L);
0478       case 115:
0479          return jjMoveStringLiteralDfa9_0(active0, 0x800L);
0480       default :
0481          break;
0482    }
0483    return jjMoveNfa_0(08);
0484 }
0485 private int jjMoveStringLiteralDfa9_0(long old0, long active0){
0486    if (((active0 &= old0)) == 0L)
0487       return jjMoveNfa_0(08);
0488    try curChar = input_stream.readChar()}
0489    catch(java.io.IOException e) {
0490    return jjMoveNfa_0(08);
0491    }
0492    switch(curChar)
0493    {
0494       case 69:
0495          return jjMoveStringLiteralDfa10_0(active0, 0x800L);
0496       case 82:
0497          return jjMoveStringLiteralDfa10_0(active0, 0xe00000L);
0498       case 101:
0499          return jjMoveStringLiteralDfa10_0(active0, 0x800L);
0500       case 114:
0501          return jjMoveStringLiteralDfa10_0(active0, 0xe00000L);
0502       default :
0503          break;
0504    }
0505    return jjMoveNfa_0(09);
0506 }
0507 private int jjMoveStringLiteralDfa10_0(long old0, long active0){
0508    if (((active0 &= old0)) == 0L)
0509       return jjMoveNfa_0(09);
0510    try curChar = input_stream.readChar()}
0511    catch(java.io.IOException e) {
0512    return jjMoveNfa_0(09);
0513    }
0514    switch(curChar)
0515    {
0516       case 58:
0517          if ((active0 & 0x800L!= 0L)
0518          {
0519             jjmatchedKind = 11;
0520             jjmatchedPos = 10;
0521          }
0522          break;
0523       case 65:
0524          return jjMoveStringLiteralDfa11_0(active0, 0x800000L);
0525       case 70:
0526          return jjMoveStringLiteralDfa11_0(active0, 0x400000L);
0527       case 83:
0528          return jjMoveStringLiteralDfa11_0(active0, 0x200000L);
0529       case 97:
0530          return jjMoveStringLiteralDfa11_0(active0, 0x800000L);
0531       case 102:
0532          return jjMoveStringLiteralDfa11_0(active0, 0x400000L);
0533       case 115:
0534          return jjMoveStringLiteralDfa11_0(active0, 0x200000L);
0535       default :
0536          break;
0537    }
0538    return jjMoveNfa_0(010);
0539 }
0540 private int jjMoveStringLiteralDfa11_0(long old0, long active0){
0541    if (((active0 &= old0)) == 0L)
0542       return jjMoveNfa_0(010);
0543    try curChar = input_stream.readChar()}
0544    catch(java.io.IOException e) {
0545    return jjMoveNfa_0(010);
0546    }
0547    switch(curChar)
0548    {
0549       case 66:
0550          return jjMoveStringLiteralDfa12_0(active0, 0x800000L);
0551       case 73:
0552          return jjMoveStringLiteralDfa12_0(active0, 0x400000L);
0553       case 84:
0554          return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
0555       case 98:
0556          return jjMoveStringLiteralDfa12_0(active0, 0x800000L);
0557       case 105:
0558          return jjMoveStringLiteralDfa12_0(active0, 0x400000L);
0559       case 116:
0560          return jjMoveStringLiteralDfa12_0(active0, 0x200000L);
0561       default :
0562          break;
0563    }
0564    return jjMoveNfa_0(011);
0565 }
0566 private int jjMoveStringLiteralDfa12_0(long old0, long active0){
0567    if (((active0 &= old0)) == 0L)
0568       return jjMoveNfa_0(011);
0569    try curChar = input_stream.readChar()}
0570    catch(java.io.IOException e) {
0571    return jjMoveNfa_0(011);
0572    }
0573    switch(curChar)
0574    {
0575       case 65:
0576          return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
0577       case 78:
0578          return jjMoveStringLiteralDfa13_0(active0, 0x400000L);
0579       case 79:
0580          return jjMoveStringLiteralDfa13_0(active0, 0x800000L);
0581       case 97:
0582          return jjMoveStringLiteralDfa13_0(active0, 0x200000L);
0583       case 110:
0584          return jjMoveStringLiteralDfa13_0(active0, 0x400000L);
0585       case 111:
0586          return jjMoveStringLiteralDfa13_0(active0, 0x800000L);
0587       default :
0588          break;
0589    }
0590    return jjMoveNfa_0(012);
0591 }
0592 private int jjMoveStringLiteralDfa13_0(long old0, long active0){
0593    if (((active0 &= old0)) == 0L)
0594       return jjMoveNfa_0(012);
0595    try curChar = input_stream.readChar()}
0596    catch(java.io.IOException e) {
0597    return jjMoveNfa_0(012);
0598    }
0599    switch(curChar)
0600    {
0601       case 73:
0602          return jjMoveStringLiteralDfa14_0(active0, 0x400000L);
0603       case 82:
0604          return jjMoveStringLiteralDfa14_0(active0, 0xa00000L);
0605       case 105:
0606          return jjMoveStringLiteralDfa14_0(active0, 0x400000L);
0607       case 114:
0608          return jjMoveStringLiteralDfa14_0(active0, 0xa00000L);
0609       default :
0610          break;
0611    }
0612    return jjMoveNfa_0(013);
0613 }
0614 private int jjMoveStringLiteralDfa14_0(long old0, long active0){
0615    if (((active0 &= old0)) == 0L)
0616       return jjMoveNfa_0(013);
0617    try curChar = input_stream.readChar()}
0618    catch(java.io.IOException e) {
0619    return jjMoveNfa_0(013);
0620    }
0621    switch(curChar)
0622    {
0623       case 83:
0624          return jjMoveStringLiteralDfa15_0(active0, 0x400000L);
0625       case 84:
0626          return jjMoveStringLiteralDfa15_0(active0, 0xa00000L);
0627       case 115:
0628          return jjMoveStringLiteralDfa15_0(active0, 0x400000L);
0629       case 116:
0630          return jjMoveStringLiteralDfa15_0(active0, 0xa00000L);
0631       default :
0632          break;
0633    }
0634    return jjMoveNfa_0(014);
0635 }
0636 private int jjMoveStringLiteralDfa15_0(long old0, long active0){
0637    if (((active0 &= old0)) == 0L)
0638       return jjMoveNfa_0(014);
0639    try curChar = input_stream.readChar()}
0640    catch(java.io.IOException e) {
0641    return jjMoveNfa_0(014);
0642    }
0643    switch(curChar)
0644    {
0645       case 69:
0646          return jjMoveStringLiteralDfa16_0(active0, 0xa00000L);
0647       case 72:
0648          return jjMoveStringLiteralDfa16_0(active0, 0x400000L);
0649       case 101:
0650          return jjMoveStringLiteralDfa16_0(active0, 0xa00000L);
0651       case 104:
0652          return jjMoveStringLiteralDfa16_0(active0, 0x400000L);
0653       default :
0654          break;
0655    }
0656    return jjMoveNfa_0(015);
0657 }
0658 private int jjMoveStringLiteralDfa16_0(long old0, long active0){
0659    if (((active0 &= old0)) == 0L)
0660       return jjMoveNfa_0(015);
0661    try curChar = input_stream.readChar()}
0662    catch(java.io.IOException e) {
0663    return jjMoveNfa_0(015);
0664    }
0665    switch(curChar)
0666    {
0667       case 68:
0668          return jjMoveStringLiteralDfa17_0(active0, 0xa00000L);
0669       case 69:
0670          return jjMoveStringLiteralDfa17_0(active0, 0x400000L);
0671       case 100:
0672          return jjMoveStringLiteralDfa17_0(active0, 0xa00000L);
0673       case 101:
0674          return jjMoveStringLiteralDfa17_0(active0, 0x400000L);
0675       default :
0676          break;
0677    }
0678    return jjMoveNfa_0(016);
0679 }
0680 private int jjMoveStringLiteralDfa17_0(long old0, long active0){
0681    if (((active0 &= old0)) == 0L)
0682       return jjMoveNfa_0(016);
0683    try curChar = input_stream.readChar()}
0684    catch(java.io.IOException e) {
0685    return jjMoveNfa_0(016);
0686    }
0687    switch(curChar)
0688    {
0689       case 58:
0690          if ((active0 & 0x200000L!= 0L)
0691          {
0692             jjmatchedKind = 21;
0693             jjmatchedPos = 17;
0694          }
0695          else if ((active0 & 0x800000L!= 0L)
0696          {
0697             jjmatchedKind = 23;
0698             jjmatchedPos = 17;
0699          }
0700          break;
0701       case 68:
0702          return jjMoveStringLiteralDfa18_0(active0, 0x400000L);
0703       case 100:
0704          return jjMoveStringLiteralDfa18_0(active0, 0x400000L);
0705       default :
0706          break;
0707    }
0708    return jjMoveNfa_0(017);
0709 }
0710 private int jjMoveStringLiteralDfa18_0(long old0, long active0){
0711    if (((active0 &= old0)) == 0L)
0712       return jjMoveNfa_0(017);
0713    try curChar = input_stream.readChar()}
0714    catch(java.io.IOException e) {
0715    return jjMoveNfa_0(017);
0716    }
0717    switch(curChar)
0718    {
0719       case 58:
0720          if ((active0 & 0x400000L!= 0L)
0721          {
0722             jjmatchedKind = 22;
0723             jjmatchedPos = 18;
0724          }
0725          break;
0726       default :
0727          break;
0728    }
0729    return jjMoveNfa_0(018);
0730 }
0731 static final long[] jjbitVec0 = {
0732    0xfffffffffffffffeL0xffffffffffffffffL0xffffffffffffffffL0xffffffffffffffffL
0733 };
0734 static final long[] jjbitVec2 = {
0735    0x0L0x0L0xffffffffffffffffL0xffffffffffffffffL
0736 };
0737 private int jjMoveNfa_0(int startState, int curPos)
0738 {
0739    int strKind = jjmatchedKind;
0740    int strPos = jjmatchedPos;
0741    int seenUpto;
0742    input_stream.backup(seenUpto = curPos + 1);
0743    try curChar = input_stream.readChar()}
0744    catch(java.io.IOException e) { throw new Error("Internal Error")}
0745    curPos = 0;
0746    int startsAt = 0;
0747    jjnewStateCnt = 64;
0748    int i = 1;
0749    jjstateSet[0= startState;
0750    int kind = 0x7fffffff;
0751    for (;;)
0752    {
0753       if (++jjround == 0x7fffffff)
0754          ReInitRounds();
0755       if (curChar < 64)
0756       {
0757          long l = 1L << curChar;
0758          do
0759          {
0760             switch(jjstateSet[--i])
0761             {
0762                case 0:
0763                   if ((0x3ff000000000000L & l!= 0L)
0764                   {
0765                      if (kind > 35)
0766                         kind = 35;
0767                      jjCheckNAddStates(07)}
0768                   }
0769                   else if ((0x100003600L & l!= 0L)
0770                   {
0771                      if (kind > 65)
0772                         kind = 65;
0773                      jjCheckNAdd(21)}
0774                   }
0775                   else if ((0x280000000000L & l!= 0L)
0776                      jjCheckNAddStates(810)}
0777                   else if ((0x5000000000000000L & l!= 0L)
0778                   {
0779                      if (kind > 33)
0780                         kind = 33;
0781                   }
0782                   else if (curChar == 47)
0783                      jjAddStates(1112)}
0784                   else if (curChar == 33)
0785                      jjCheckNAddStates(1315)}
0786                   else if (curChar == 61)
0787                      jjCheckNAddStates(1618)}
0788                   else if (curChar == 35)
0789                      jjstateSet[jjnewStateCnt++30;
0790                   else if (curChar == 59)
0791                      jjstateSet[jjnewStateCnt++22;
0792                   else if (curChar == 46)
0793                      jjCheckNAdd(16)}
0794                   if ((0x80000c0000000000L & l!= 0L)
0795                   {
0796                      if (kind > 32)
0797                         kind = 32;
0798                   }
0799                   else if (curChar == 60)
0800                      jjCheckNAdd(2)}
0801                   else if (curChar == 62)
0802                      jjCheckNAdd(2)}
0803                   break;
0804                case 1:
0805                   if ((0x5000000000000000L & l!= 0L && kind > 33)
0806                      kind = 33;
0807                   break;
0808                case 2:
0809                   if (curChar == 61 && kind > 33)
0810                      kind = 33;
0811                   break;
0812                case 3:
0813                   if (curChar == 62)
0814                      jjCheckNAdd(2)}
0815                   break;
0816                case 4:
0817                   if (curChar == 60)
0818                      jjCheckNAdd(2)}
0819                   break;
0820                case 14:
0821                   if ((0x3ff200000000000L & l== 0L)
0822                      break;
0823                   if (kind > 49)
0824                      kind = 49;
0825                   jjstateSet[jjnewStateCnt++14;
0826                   break;
0827                case 15:
0828                   if (curChar == 46)
0829                      jjCheckNAdd(16)}
0830                   break;
0831                case 16:
0832                   if ((0x3ff000000000000L & l== 0L)
0833                      break;
0834                   if (kind > 50)
0835                      kind = 50;
0836                   jjCheckNAddStates(1921)}
0837                   break;
0838                case 18:
0839                   if ((0x280000000000L & l!= 0L)
0840                      jjCheckNAdd(19)}
0841                   break;
0842                case 19:
0843                   if ((0x3ff000000000000L & l== 0L)
0844                      break;
0845                   if (kind > 50)
0846                      kind = 50;
0847                   jjCheckNAddTwoStates(1920)}
0848                   break;
0849                case 21:
0850                   if ((0x100003600L & l== 0L)
0851                      break;
0852                   if (kind > 65)
0853                      kind = 65;
0854                   jjCheckNAdd(21)}
0855                   break;
0856                case 22:
0857                   if (curChar != 59)
0858                      break;
0859                   if (kind > 67)
0860                      kind = 67;
0861                   jjCheckNAddStates(2225)}
0862                   break;
0863                case 23:
0864                   if ((0xffffffffffffdbffL & l== 0L)
0865                      break;
0866                   if (kind > 67)
0867                      kind = 67;
0868                   jjCheckNAddStates(2225)}
0869                   break;
0870                case 24:
0871                   if ((0x2400L & l!= 0L && kind > 67)
0872                      kind = 67;
0873                   break;
0874                case 25:
0875                   if (curChar == 13 && kind > 67)
0876                      kind = 67;
0877                   break;
0878                case 26:
0879                   if (curChar == 10)
0880                      jjstateSet[jjnewStateCnt++25;
0881                   break;
0882                case 27:
0883                   if (curChar == 10 && kind > 67)
0884                      kind = 67;
0885                   break;
0886                case 28:
0887                   if (curChar == 13)
0888                      jjstateSet[jjnewStateCnt++27;
0889                   break;
0890                case 29:
0891                   if (curChar == 59)
0892                      jjstateSet[jjnewStateCnt++22;
0893                   break;
0894                case 31:
0895                   if (curChar == 35)
0896                      jjstateSet[jjnewStateCnt++30;
0897                   break;
0898                case 32:
0899                   if (curChar == 61)
0900                      jjCheckNAddStates(1618)}
0901                   break;
0902                case 34:
0903                case 36:
0904                   if (curChar == 61)
0905                      jjCheckNAdd(33)}
0906                   break;
0907                case 35:
0908                   if (curChar == 33)
0909                      jjCheckNAddStates(1315)}
0910                   break;
0911                case 37:
0912                   if ((0x280000000000L & l!= 0L)
0913                      jjCheckNAddStates(810)}
0914                   break;
0915                case 38:
0916                   if ((0x3ff000000000000L & l== 0L)
0917                      break;
0918                   if (kind > 35)
0919                      kind = 35;
0920                   jjCheckNAdd(38)}
0921                   break;
0922                case 39:
0923                   if ((0x3ff000000000000L & l!= 0L)
0924                      jjCheckNAddStates(2632)}
0925                   break;
0926                case 40:
0927                   if ((0x3ff000000000000L & l!= 0L)
0928                      jjCheckNAddTwoStates(4041)}
0929                   break;
0930                case 41:
0931                   if (curChar != 46)
0932                      break;
0933                   if (kind > 50)
0934                      kind = 50;
0935                   jjCheckNAddStates(3335)}
0936                   break;
0937                case 42:
0938                   if ((0x3ff000000000000L & l== 0L)
0939                      break;
0940                   if (kind > 50)
0941                      kind = 50;
0942                   jjCheckNAddStates(3335)}
0943                   break;
0944                case 44:
0945                   if ((0x280000000000L & l!= 0L)
0946                      jjCheckNAdd(45)}
0947                   break;
0948                case 45:
0949                   if ((0x3ff000000000000L & l== 0L)
0950                      break;
0951                   if (kind > 50)
0952                      kind = 50;
0953                   jjCheckNAddTwoStates(4520)}
0954                   break;
0955                case 46:
0956                   if ((0x3ff000000000000L & l!= 0L)
0957                      jjCheckNAddTwoStates(4647)}
0958                   break;
0959                case 48:
0960                   if ((0x280000000000L & l!= 0L)
0961                      jjCheckNAdd(49)}
0962                   break;
0963                case 49:
0964                   if ((0x3ff000000000000L & l== 0L)
0965                      break;
0966                   if (kind > 50)
0967                      kind = 50;
0968                   jjCheckNAddTwoStates(4920)}
0969                   break;
0970                case 50:
0971                   if ((0x3ff000000000000L & l!= 0L)
0972                      jjCheckNAddStates(3638)}
0973                   break;
0974                case 52:
0975                   if ((0x280000000000L & l!= 0L)
0976                      jjCheckNAdd(53)}
0977                   break;
0978                case 53:
0979                   if ((0x3ff000000000000L & l!= 0L)
0980                      jjCheckNAddTwoStates(5320)}
0981                   break;
0982                case 54:
0983                   if ((0x3ff000000000000L & l== 0L)
0984                      break;
0985                   if (kind > 35)
0986                      kind = 35;
0987                   jjCheckNAddStates(07)}
0988                   break;
0989                case 55:
0990                   if (curChar == 47)
0991                      jjAddStates(1112)}
0992                   break;
0993                case 56:
0994                   if (curChar != 47)
0995                      break;
0996                   if (kind > 66)
0997                      kind = 66;
0998                   jjCheckNAddStates(3942)}
0999                   break;
1000                case 57:
1001                   if ((0xffffffffffffdbffL & l== 0L)
1002                      break;
1003                   if (kind > 66)
1004                      kind = 66;
1005                   jjCheckNAddStates(3942)}
1006                   break;
1007                case 58:
1008                   if ((0x2400L & l!= 0L && kind > 66)
1009                      kind = 66;
1010                   break;
1011                case 59:
1012                   if (curChar == 13 && kind > 66)
1013                      kind = 66;
1014                   break;
1015                case 60:
1016                   if (curChar == 10)
1017                      jjstateSet[jjnewStateCnt++59;
1018                   break;
1019                case 61:
1020                   if (curChar == 10 && kind > 66)
1021                      kind = 66;
1022                   break;
1023                case 62:
1024                   if (curChar == 13)
1025                      jjstateSet[jjnewStateCnt++61;
1026                   break;
1027                case 63:
1028                   if (curChar == 42 && kind > 68)
1029                      kind = 68;
1030                   break;
1031                default break;
1032             }
1033          while(i != startsAt);
1034       }
1035       else if (curChar < 128)
1036       {
1037          long l = 1L << (curChar & 077);
1038          do
1039          {
1040             switch(jjstateSet[--i])
1041             {
1042                case 0:
1043                   if ((0x7fffffe87fffffeL & l!= 0L)
1044                   {
1045                      if (kind > 49)
1046                         kind = 49;
1047                      jjCheckNAdd(14)}
1048                   }
1049                   if (curChar == 102)
1050                      jjstateSet[jjnewStateCnt++11;
1051                   else if (curChar == 116)
1052                      jjstateSet[jjnewStateCnt++7;
1053                   break;
1054                case 5:
1055                   if (curChar == 101 && kind > 48)
1056                      kind = 48;
1057                   break;
1058                case 6:
1059                   if (curChar == 117)
1060                      jjCheckNAdd(5)}
1061                   break;
1062                case 7:
1063                   if (curChar == 114)
1064                      jjstateSet[jjnewStateCnt++6;
1065                   break;
1066                case 8:
1067                   if (curChar == 116)
1068                      jjstateSet[jjnewStateCnt++7;
1069                   break;
1070                case 9:
1071                   if (curChar == 115)
1072                      jjCheckNAdd(5)}
1073                   break;
1074                case 10:
1075                   if (curChar == 108)
1076                      jjstateSet[jjnewStateCnt++9;
1077                   break;
1078                case 11:
1079                   if (curChar == 97)
1080                      jjstateSet[jjnewStateCnt++10;
1081                   break;
1082                case 12:
1083                   if (curChar == 102)
1084                      jjstateSet[jjnewStateCnt++11;
1085                   break;
1086                case 13:
1087                case 14:
1088                   if ((0x7fffffe87fffffeL & l== 0L)
1089                      break;
1090                   if (kind > 49)
1091                      kind = 49;
1092                   jjCheckNAdd(14)}
1093                   break;
1094                case 17:
1095                   if ((0x2000000020L & l!= 0L)
1096                      jjAddStates(4344)}
1097                   break;
1098                case 20:
1099                   if ((0x5000000050L & l!= 0L && kind > 50)
1100                      kind = 50;
1101                   break;
1102                case 23:
1103                   if (kind > 67)
1104                      kind = 67;
1105                   jjAddStates(2225)}
1106                   break;
1107                case 30:
1108                   if (curChar == 124 && kind > 68)
1109                      kind = 68;
1110                   break;
1111                case 33:
1112                   if (curChar == 126 && kind > 33)
1113                      kind = 33;
1114                   break;
1115                case 43:
1116                   if ((0x2000000020L & l!= 0L)
1117                      jjAddStates(4546)}
1118                   break;
1119                case 47:
1120                   if ((0x2000000020L & l!= 0L)
1121                      jjAddStates(4748)}
1122                   break;
1123                case 51:
1124                   if ((0x2000000020L & l!= 0L)
1125                      jjAddStates(4950)}
1126                   break;
1127                case 57:
1128                   if (kind > 66)
1129                      kind = 66;
1130                   jjAddStates(3942)}
1131                   break;
1132                default break;
1133             }
1134          while(i != startsAt);
1135       }
1136       else
1137       {
1138          int hiByte = (curChar >> 8);
1139          int i1 = hiByte >> 6;
1140          long l1 = 1L << (hiByte & 077);
1141          int i2 = (curChar & 0xff>> 6;
1142          long l2 = 1L << (curChar & 077);
1143          do
1144          {
1145             switch(jjstateSet[--i])
1146             {
1147                case 23:
1148                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1149                      break;
1150                   if (kind > 67)
1151                      kind = 67;
1152                   jjAddStates(2225)}
1153                   break;
1154                case 57:
1155                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1156                      break;
1157                   if (kind > 66)
1158                      kind = 66;
1159                   jjAddStates(3942)}
1160                   break;
1161                default if (i1 == || l1 == || i2 == ||  l2 == 0breakelse break;
1162             }
1163          while(i != startsAt);
1164       }
1165       if (kind != 0x7fffffff)
1166       {
1167          jjmatchedKind = kind;
1168          jjmatchedPos = curPos;
1169          kind = 0x7fffffff;
1170       }
1171       ++curPos;
1172       if ((i = jjnewStateCnt== (startsAt = 64 (jjnewStateCnt = startsAt)))
1173          break;
1174       try curChar = input_stream.readChar()}
1175       catch(java.io.IOException e) { break}
1176    }
1177    if (jjmatchedPos > strPos)
1178       return curPos;
1179 
1180    int toRet = Math.max(curPos, seenUpto);
1181 
1182    if (curPos < toRet)
1183       for (i = toRet - Math.min(curPos, seenUpto); i-- > 0)
1184          try curChar = input_stream.readChar()}
1185          catch(java.io.IOException e) { throw new Error("Internal Error : Please send a bug report.")}
1186 
1187    if (jjmatchedPos < strPos)
1188    {
1189       jjmatchedKind = strKind;
1190       jjmatchedPos = strPos;
1191    }
1192    else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
1193       jjmatchedKind = strKind;
1194 
1195    return toRet;
1196 }
1197 private final int jjStopStringLiteralDfa_3(int pos, long active0){
1198    switch (pos)
1199    {
1200       case 0:
1201          if ((active0 & 0x1fe000000000L!= 0L)
1202             return 0;
1203          return -1;
1204       default :
1205          return -1;
1206    }
1207 }
1208 private final int jjStartNfa_3(int pos, long active0){
1209    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
1210 }
1211 private int jjMoveStringLiteralDfa0_3(){
1212    switch(curChar)
1213    {
1214       case 34:
1215          return jjStopAtPos(047);
1216       case 92:
1217          return jjMoveStringLiteralDfa1_3(0x1fe000000000L);
1218       default :
1219          return jjMoveNfa_3(50);
1220    }
1221 }
1222 private int jjMoveStringLiteralDfa1_3(long active0){
1223    try curChar = input_stream.readChar()}
1224    catch(java.io.IOException e) {
1225       jjStopStringLiteralDfa_3(0, active0);
1226       return 1;
1227    }
1228    switch(curChar)
1229    {
1230       case 34:
1231          if ((active0 & 0x40000000000L!= 0L)
1232             return jjStopAtPos(142);
1233          break;
1234       case 39:
1235          if ((active0 & 0x80000000000L!= 0L)
1236             return jjStopAtPos(143);
1237          break;
1238       case 92:
1239          if ((active0 & 0x100000000000L!= 0L)
1240             return jjStopAtPos(144);
1241          break;
1242       case 98:
1243          if ((active0 & 0x10000000000L!= 0L)
1244             return jjStopAtPos(140);
1245          break;
1246       case 102:
1247          if ((active0 & 0x20000000000L!= 0L)
1248             return jjStopAtPos(141);
1249          break;
1250       case 110:
1251          if ((active0 & 0x2000000000L!= 0L)
1252             return jjStopAtPos(137);
1253          break;
1254       case 114:
1255          if ((active0 & 0x4000000000L!= 0L)
1256             return jjStopAtPos(138);
1257          break;
1258       case 116:
1259          if ((active0 & 0x8000000000L!= 0L)
1260             return jjStopAtPos(139);
1261          break;
1262       default :
1263          break;
1264    }
1265    return jjStartNfa_3(0, active0);
1266 }
1267 private int jjMoveNfa_3(int startState, int curPos)
1268 {
1269    int startsAt = 0;
1270    jjnewStateCnt = 7;
1271    int i = 1;
1272    jjstateSet[0= startState;
1273    int kind = 0x7fffffff;
1274    for (;;)
1275    {
1276       if (++jjround == 0x7fffffff)
1277          ReInitRounds();
1278       if (curChar < 64)
1279       {
1280          long l = 1L << curChar;
1281          do
1282          {
1283             switch(jjstateSet[--i])
1284             {
1285                case 5:
1286                   if ((0xfffffffbffffffffL & l!= 0L && kind > 46)
1287                      kind = 46;
1288                   break;
1289                case 1:
1290                   if ((0x3ff000000000000L & l!= 0L)
1291                      jjstateSet[jjnewStateCnt++2;
1292                   break;
1293                case 2:
1294                   if ((0x3ff000000000000L & l!= 0L)
1295                      jjstateSet[jjnewStateCnt++3;
1296                   break;
1297                case 3:
1298                   if ((0x3ff000000000000L & l!= 0L)
1299                      jjstateSet[jjnewStateCnt++4;
1300                   break;
1301                case 4:
1302                   if ((0x3ff000000000000L & l!= 0L && kind > 45)
1303                      kind = 45;
1304                   break;
1305                default break;
1306             }
1307          while(i != startsAt);
1308       }
1309       else if (curChar < 128)
1310       {
1311          long l = 1L << (curChar & 077);
1312          do
1313          {
1314             switch(jjstateSet[--i])
1315             {
1316                case 5:
1317                   if ((0xffffffffefffffffL & l!= 0L)
1318                   {
1319                      if (kind > 46)
1320                         kind = 46;
1321                   }
1322                   else if (curChar == 92)
1323                      jjstateSet[jjnewStateCnt++0;
1324                   break;
1325                case 0:
1326                   if (curChar == 117)
1327                      jjstateSet[jjnewStateCnt++1;
1328                   break;
1329                case 1:
1330                   if ((0x7e0000007eL & l!= 0L)
1331                      jjstateSet[jjnewStateCnt++2;
1332                   break;
1333                case 2:
1334                   if ((0x7e0000007eL & l!= 0L)
1335                      jjstateSet[jjnewStateCnt++3;
1336                   break;
1337                case 3:
1338                   if ((0x7e0000007eL & l!= 0L)
1339                      jjstateSet[jjnewStateCnt++4;
1340                   break;
1341                case 4:
1342                   if ((0x7e0000007eL & l!= 0L && kind > 45)
1343                      kind = 45;
1344                   break;
1345                case 6:
1346                   if ((0xffffffffefffffffL & l!= 0L && kind > 46)
1347                      kind = 46;
1348                   break;
1349                default break;
1350             }
1351          while(i != startsAt);
1352       }
1353       else
1354       {
1355          int hiByte = (curChar >> 8);
1356          int i1 = hiByte >> 6;
1357          long l1 = 1L << (hiByte & 077);
1358          int i2 = (curChar & 0xff>> 6;
1359          long l2 = 1L << (curChar & 077);
1360          do
1361          {
1362             switch(jjstateSet[--i])
1363             {
1364                case 5:
1365                   if (jjCanMove_0(hiByte, i1, i2, l1, l2&& kind > 46)
1366                      kind = 46;
1367                   break;
1368                default if (i1 == || l1 == || i2 == ||  l2 == 0breakelse break;
1369             }
1370          while(i != startsAt);
1371       }
1372       if (kind != 0x7fffffff)
1373       {
1374          jjmatchedKind = kind;
1375          jjmatchedPos = curPos;
1376          kind = 0x7fffffff;
1377       }
1378       ++curPos;
1379       if ((i = jjnewStateCnt== (startsAt = (jjnewStateCnt = startsAt)))
1380          return curPos;
1381       try curChar = input_stream.readChar()}
1382       catch(java.io.IOException e) { return curPos; }
1383    }
1384 }
1385 private int jjMoveStringLiteralDfa0_1()
1386 {
1387    return jjMoveNfa_1(90);
1388 }
1389 private int jjMoveNfa_1(int startState, int curPos)
1390 {
1391    int startsAt = 0;
1392    jjnewStateCnt = 21;
1393    int i = 1;
1394    jjstateSet[0= startState;
1395    int kind = 0x7fffffff;
1396    for (;;)
1397    {
1398       if (++jjround == 0x7fffffff)
1399          ReInitRounds();
1400       if (curChar < 64)
1401       {
1402          long l = 1L << curChar;
1403          do
1404          {
1405             switch(jjstateSet[--i])
1406             {
1407                case 9:
1408                   if ((0x3ffe00000000000L & l!= 0L)
1409                   {
1410                      if (kind > 13)
1411                         kind = 13;
1412                      jjCheckNAdd(0)}
1413                   }
1414                   else if ((0x100003600L & l!= 0L)
1415                   {
1416                      if (kind > 14)
1417                         kind = 14;
1418                      jjCheckNAdd(1)}
1419                   }
1420                   else if (curChar == 35)
1421                      jjstateSet[jjnewStateCnt++10;
1422                   else if (curChar == 59)
1423                      jjstateSet[jjnewStateCnt++2;
1424                   if (curChar == 47)
1425                      jjAddStates(5152)}
1426                   break;
1427                case 0:
1428                   if ((0x3ffe00000000000L & l== 0L)
1429                      break;
1430                   if (kind > 13)
1431                      kind = 13;
1432                   jjCheckNAdd(0)}
1433                   break;
1434                case 1:
1435                   if ((0x100003600L & l== 0L)
1436                      break;
1437                   if (kind > 14)
1438                      kind = 14;
1439                   jjCheckNAdd(1)}
1440                   break;
1441                case 2:
1442                   if (curChar != 59)
1443                      break;
1444                   if (kind > 16)
1445                      kind = 16;
1446                   jjCheckNAddStates(5356)}
1447                   break;
1448                case 3:
1449                   if ((0xffffffffffffdbffL & l== 0L)
1450                      break;
1451                   if (kind > 16)
1452                      kind = 16;
1453                   jjCheckNAddStates(5356)}
1454                   break;
1455                case 4:
1456                   if ((0x2400L & l!= 0L && kind > 16)
1457                      kind = 16;
1458                   break;
1459                case 5:
1460                   if (curChar == 13 && kind > 16)
1461                      kind = 16;
1462                   break;
1463                case 6:
1464                   if (curChar == 10)
1465                      jjstateSet[jjnewStateCnt++5;
1466                   break;
1467                case 7:
1468                   if (curChar == 10 && kind > 16)
1469                      kind = 16;
1470                   break;
1471                case 8:
1472                   if (curChar == 13)
1473                      jjstateSet[jjnewStateCnt++7;
1474                   break;
1475                case 11:
1476                   if (curChar == 35)
1477                      jjstateSet[jjnewStateCnt++10;
1478                   break;
1479                case 12:
1480                   if (curChar == 47)
1481                      jjAddStates(5152)}
1482                   break;
1483                case 13:
1484                   if (curChar != 47)
1485                      break;
1486                   if (kind > 15)
1487                      kind = 15;
1488                   jjCheckNAddStates(5760)}
1489                   break;
1490                case 14:
1491                   if ((0xffffffffffffdbffL & l== 0L)
1492                      break;
1493                   if (kind > 15)
1494                      kind = 15;
1495                   jjCheckNAddStates(5760)}
1496                   break;
1497                case 15:
1498                   if ((0x2400L & l!= 0L && kind > 15)
1499                      kind = 15;
1500                   break;
1501                case 16:
1502                   if (curChar == 13 && kind > 15)
1503                      kind = 15;
1504                   break;
1505                case 17:
1506                   if (curChar == 10)
1507                      jjstateSet[jjnewStateCnt++16;
1508                   break;
1509                case 18:
1510                   if (curChar == 10 && kind > 15)
1511                      kind = 15;
1512                   break;
1513                case 19:
1514                   if (curChar == 13)
1515                      jjstateSet[jjnewStateCnt++18;
1516                   break;
1517                case 20:
1518                   if (curChar == 42 && kind > 17)
1519                      kind = 17;
1520                   break;
1521                default break;
1522             }
1523          while(i != startsAt);
1524       }
1525       else if (curChar < 128)
1526       {
1527          long l = 1L << (curChar & 077);
1528          do
1529          {
1530             switch(jjstateSet[--i])
1531             {
1532                case 9:
1533                case 0:
1534                   if ((0x7fffffe97fffffeL & l== 0L)
1535                      break;
1536                   if (kind > 13)
1537                      kind = 13;
1538                   jjCheckNAdd(0)}
1539                   break;
1540                case 3:
1541                   if (kind > 16)
1542                      kind = 16;
1543                   jjAddStates(5356)}
1544                   break;
1545                case 10:
1546                   if (curChar == 124 && kind > 17)
1547                      kind = 17;
1548                   break;
1549                case 14:
1550                   if (kind > 15)
1551                      kind = 15;
1552                   jjAddStates(5760)}
1553                   break;
1554                default break;
1555             }
1556          while(i != startsAt);
1557       }
1558       else
1559       {
1560          int hiByte = (curChar >> 8);
1561          int i1 = hiByte >> 6;
1562          long l1 = 1L << (hiByte & 077);
1563          int i2 = (curChar & 0xff>> 6;
1564          long l2 = 1L << (curChar & 077);
1565          do
1566          {
1567             switch(jjstateSet[--i])
1568             {
1569                case 3:
1570                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1571                      break;
1572                   if (kind > 16)
1573                      kind = 16;
1574                   jjAddStates(5356)}
1575                   break;
1576                case 14:
1577                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1578                      break;
1579                   if (kind > 15)
1580                      kind = 15;
1581                   jjAddStates(5760)}
1582                   break;
1583                default if (i1 == || l1 == || i2 == ||  l2 == 0breakelse break;
1584             }
1585          while(i != startsAt);
1586       }
1587       if (kind != 0x7fffffff)
1588       {
1589          jjmatchedKind = kind;
1590          jjmatchedPos = curPos;
1591          kind = 0x7fffffff;
1592       }
1593       ++curPos;
1594       if ((i = jjnewStateCnt== (startsAt = 21 (jjnewStateCnt = startsAt)))
1595          return curPos;
1596       try curChar = input_stream.readChar()}
1597       catch(java.io.IOException e) { return curPos; }
1598    }
1599 }
1600 private int jjMoveStringLiteralDfa0_4()
1601 {
1602    return jjMoveNfa_4(10);
1603 }
1604 private int jjMoveNfa_4(int startState, int curPos)
1605 {
1606    int startsAt = 0;
1607    jjnewStateCnt = 4;
1608    int i = 1;
1609    jjstateSet[0= startState;
1610    int kind = 0x7fffffff;
1611    for (;;)
1612    {
1613       if (++jjround == 0x7fffffff)
1614          ReInitRounds();
1615       if (curChar < 64)
1616       {
1617          long l = 1L << curChar;
1618          do
1619          {
1620             switch(jjstateSet[--i])
1621             {
1622                case 1:
1623                   if (curChar == 42)
1624                      jjstateSet[jjnewStateCnt++0;
1625                   break;
1626                case 0:
1627                   if (curChar == 47)
1628                      kind = 70;
1629                   break;
1630                case 2:
1631                   if (curChar == 35)
1632                      kind = 70;
1633                   break;
1634                default break;
1635             }
1636          while(i != startsAt);
1637       }
1638       else if (curChar < 128)
1639       {
1640          long l = 1L << (curChar & 077);
1641          do
1642          {
1643             switch(jjstateSet[--i])
1644             {
1645                case 1:
1646                   if (curChar == 124)
1647                      jjstateSet[jjnewStateCnt++2;
1648                   break;
1649                default break;
1650             }
1651          while(i != startsAt);
1652       }
1653       else
1654       {
1655          int hiByte = (curChar >> 8);
1656          int i1 = hiByte >> 6;
1657          long l1 = 1L << (hiByte & 077);
1658          int i2 = (curChar & 0xff>> 6;
1659          long l2 = 1L << (curChar & 077);
1660          do
1661          {
1662             switch(jjstateSet[--i])
1663             {
1664                default if (i1 == || l1 == || i2 == ||  l2 == 0breakelse break;
1665             }
1666          while(i != startsAt);
1667       }
1668       if (kind != 0x7fffffff)
1669       {
1670          jjmatchedKind = kind;
1671          jjmatchedPos = curPos;
1672          kind = 0x7fffffff;
1673       }
1674       ++curPos;
1675       if ((i = jjnewStateCnt== (startsAt = (jjnewStateCnt = startsAt)))
1676          return curPos;
1677       try curChar = input_stream.readChar()}
1678       catch(java.io.IOException e) { return curPos; }
1679    }
1680 }
1681 private int jjMoveStringLiteralDfa0_2()
1682 {
1683    return jjMoveNfa_2(10);
1684 }
1685 private int jjMoveNfa_2(int startState, int curPos)
1686 {
1687    int startsAt = 0;
1688    jjnewStateCnt = 4;
1689    int i = 1;
1690    jjstateSet[0= startState;
1691    int kind = 0x7fffffff;
1692    for (;;)
1693    {
1694       if (++jjround == 0x7fffffff)
1695          ReInitRounds();
1696       if (curChar < 64)
1697       {
1698          long l = 1L << curChar;
1699          do
1700          {
1701             switch(jjstateSet[--i])
1702             {
1703                case 1:
1704                   if (curChar == 42)
1705                      jjstateSet[jjnewStateCnt++0;
1706                   break;
1707                case 0:
1708                   if (curChar == 47)
1709                      kind = 19;
1710                   break;
1711                case 2:
1712                   if (curChar == 35)
1713                      kind = 19;
1714                   break;
1715                default break;
1716             }
1717          while(i != startsAt);
1718       }
1719       else if (curChar < 128)
1720       {
1721          long l = 1L << (curChar & 077);
1722          do
1723          {
1724             switch(jjstateSet[--i])
1725             {
1726                case 1:
1727                   if (curChar == 124)
1728                      jjstateSet[jjnewStateCnt++2;
1729                   break;
1730                default break;
1731             }
1732          while(i != startsAt);
1733       }
1734       else
1735       {
1736          int hiByte = (curChar >> 8);
1737          int i1 = hiByte >> 6;
1738          long l1 = 1L << (hiByte & 077);
1739          int i2 = (curChar & 0xff>> 6;
1740          long l2 = 1L << (curChar & 077);
1741          do
1742          {
1743             switch(jjstateSet[--i])
1744             {
1745                default if (i1 == || l1 == || i2 == ||  l2 == 0breakelse break;
1746             }
1747          while(i != startsAt);
1748       }
1749       if (kind != 0x7fffffff)
1750       {
1751          jjmatchedKind = kind;
1752          jjmatchedPos = curPos;
1753          kind = 0x7fffffff;
1754       }
1755       ++curPos;
1756       if ((i = jjnewStateCnt== (startsAt = (jjnewStateCnt = startsAt)))
1757          return curPos;
1758       try curChar = input_stream.readChar()}
1759       catch(java.io.IOException e) { return curPos; }
1760    }
1761 }
1762 static final int[] jjnextStates = {
1763    3840414647505120381539566323336
1764    2333416172023242628404146475051
1765    20424320505120575860621819444548
1766    4952531320346814151719
1767 };
1768 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1769 {
1770    switch(hiByte)
1771    {
1772       case 0:
1773          return ((jjbitVec2[i2& l2!= 0L);
1774       default :
1775          if ((jjbitVec0[i1& l1!= 0L)
1776             return true;
1777          return false;
1778    }
1779 }
1780 
1781 /** Token literal values. */
1782 public static final String[] jjstrLiteralImages = {
1783 "", null, null, null, null, null, null, null, null, null, null, null, null, 
1784 null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
1785 null, null, null, null, "\41", null, null, "\100", null, null, null, null, null, 
1786 null, null, null, null, null, null, null, null, null, null, null, null, "\72"
1787 "\73""\56""\174""\54""\173""\175""\50""\51""\133""\135""\75"
1788 "\72\53", null, null, null, null, null, null, null, "\55\55\76"};
1789 protected Token jjFillToken()
1790 {
1791    final Token t;
1792    final String curTokenImage;
1793    final int beginLine;
1794    final int endLine;
1795    final int beginColumn;
1796    final int endColumn;
1797    String im = jjstrLiteralImages[jjmatchedKind];
1798    curTokenImage = (im == null? input_stream.GetImage() : im;
1799    beginLine = input_stream.getBeginLine();
1800    beginColumn = input_stream.getBeginColumn();
1801    endLine = input_stream.getEndLine();
1802    endColumn = input_stream.getEndColumn();
1803    t = Token.newToken(jjmatchedKind, curTokenImage);
1804 
1805    t.beginLine = beginLine;
1806    t.endLine = endLine;
1807    t.beginColumn = beginColumn;
1808    t.endColumn = endColumn;
1809 
1810    return t;
1811 }
1812 
1813 int curLexState = 0;
1814 int defaultLexState = 0;
1815 int jjnewStateCnt;
1816 int jjround;
1817 int jjmatchedPos;
1818 int jjmatchedKind;
1819 
1820 /** Get the next Token. */
1821 public Token getNextToken() 
1822 {
1823   Token specialToken = null;
1824   Token matchedToken;
1825   int curPos = 0;
1826 
1827   EOFLoop :
1828   for (;;)
1829   {
1830    try
1831    {
1832       curChar = input_stream.BeginToken();
1833    }
1834    catch(java.io.IOException e)
1835    {
1836       jjmatchedKind = 0;
1837       jjmatchedPos = -1;
1838       matchedToken = jjFillToken();
1839       matchedToken.specialToken = specialToken;
1840       return matchedToken;
1841    }
1842    image = jjimage;
1843    image.setLength(0);
1844    jjimageLen = 0;
1845 
1846    for (;;)
1847    {
1848      switch(curLexState)
1849      {
1850        case 0:
1851          jjmatchedKind = 0x7fffffff;
1852          jjmatchedPos = 0;
1853          curPos = jjMoveStringLiteralDfa0_0();
1854          if (jjmatchedPos == && jjmatchedKind > 71)
1855          {
1856             jjmatchedKind = 71;
1857          }
1858          break;
1859        case 1:
1860          jjmatchedKind = 0x7fffffff;
1861          jjmatchedPos = 0;
1862          curPos = jjMoveStringLiteralDfa0_1();
1863          break;
1864        case 2:
1865          jjmatchedKind = 0x7fffffff;
1866          jjmatchedPos = 0;
1867          curPos = jjMoveStringLiteralDfa0_2();
1868          if (jjmatchedPos == && jjmatchedKind > 18)
1869          {
1870             jjmatchedKind = 18;
1871          }
1872          break;
1873        case 3:
1874          jjmatchedKind = 0x7fffffff;
1875          jjmatchedPos = 0;
1876          curPos = jjMoveStringLiteralDfa0_3();
1877          break;
1878        case 4:
1879          jjmatchedKind = 0x7fffffff;
1880          jjmatchedPos = 0;
1881          curPos = jjMoveStringLiteralDfa0_4();
1882          if (jjmatchedPos == && jjmatchedKind > 69)
1883          {
1884             jjmatchedKind = 69;
1885          }
1886          break;
1887      }
1888      if (jjmatchedKind != 0x7fffffff)
1889      {
1890         if (jjmatchedPos + < curPos)
1891            input_stream.backup(curPos - jjmatchedPos - 1);
1892         if ((jjtoToken[jjmatchedKind >> 6(1L << (jjmatchedKind & 077))) != 0L)
1893         {
1894            matchedToken = jjFillToken();
1895            matchedToken.specialToken = specialToken;
1896            TokenLexicalActions(matchedToken);
1897        if (jjnewLexState[jjmatchedKind!= -1)
1898          curLexState = jjnewLexState[jjmatchedKind];
1899            return matchedToken;
1900         }
1901         else if ((jjtoSkip[jjmatchedKind >> 6(1L << (jjmatchedKind & 077))) != 0L)
1902         {
1903            if ((jjtoSpecial[jjmatchedKind >> 6(1L << (jjmatchedKind & 077))) != 0L)
1904            {
1905               matchedToken = jjFillToken();
1906               if (specialToken == null)
1907                  specialToken = matchedToken;
1908               else
1909               {
1910                  matchedToken.specialToken = specialToken;
1911                  specialToken = (specialToken.next = matchedToken);
1912               }
1913               SkipLexicalActions(matchedToken);
1914            }
1915            else
1916               SkipLexicalActions(null);
1917          if (jjnewLexState[jjmatchedKind!= -1)
1918            curLexState = jjnewLexState[jjmatchedKind];
1919            continue EOFLoop;
1920         }
1921         MoreLexicalActions();
1922       if (jjnewLexState[jjmatchedKind!= -1)
1923         curLexState = jjnewLexState[jjmatchedKind];
1924         curPos = 0;
1925         jjmatchedKind = 0x7fffffff;
1926         try {
1927            curChar = input_stream.readChar();
1928            continue;
1929         }
1930         catch (java.io.IOException e1) { }
1931      }
1932      int error_line = input_stream.getEndLine();
1933      int error_column = input_stream.getEndColumn();
1934      String error_after = null;
1935      boolean EOFSeen = false;
1936      try input_stream.readChar(); input_stream.backup(1)}
1937      catch (java.io.IOException e1) {
1938         EOFSeen = true;
1939         error_after = curPos <= "" : input_stream.GetImage();
1940         if (curChar == '\n' || curChar == '\r') {
1941            error_line++;
1942            error_column = 0;
1943         }
1944         else
1945            error_column++;
1946      }
1947      if (!EOFSeen) {
1948         input_stream.backup(1);
1949         error_after = curPos <= "" : input_stream.GetImage();
1950      }
1951      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1952    }
1953   }
1954 }
1955 
1956 void SkipLexicalActions(Token matchedToken)
1957 {
1958    switch(jjmatchedKind)
1959    {
1960       default :
1961          break;
1962    }
1963 }
1964 void MoreLexicalActions()
1965 {
1966    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1967    switch(jjmatchedKind)
1968    {
1969       case 37 :
1970          image.append(input_stream.GetSuffix(jjimageLen));
1971          jjimageLen = 0;
1972                image.setLength(image.length() 2); image.append("\u005cn");
1973          break;
1974       case 38 :
1975          image.append(input_stream.GetSuffix(jjimageLen));
1976          jjimageLen = 0;
1977                image.setLength(image.length() 2); image.append("\u005cr");
1978          break;
1979       case 39 :
1980          image.append(input_stream.GetSuffix(jjimageLen));
1981          jjimageLen = 0;
1982                image.setLength(image.length() 2); image.append("\u005ct");
1983          break;
1984       case 40 :
1985          image.append(input_stream.GetSuffix(jjimageLen));
1986          jjimageLen = 0;
1987                image.setLength(image.length() 2); image.append("\u005cb");
1988          break;
1989       case 41 :
1990          image.append(input_stream.GetSuffix(jjimageLen));
1991          jjimageLen = 0;
1992                image.setLength(image.length() 2); image.append("\u005cf");
1993          break;
1994       case 42 :
1995          image.append(input_stream.GetSuffix(jjimageLen));
1996          jjimageLen = 0;
1997                 image.setLength(image.length() 2); image.append("\u005c"");
1998          break;
1999       case 43 :
2000          image.append(input_stream.GetSuffix(jjimageLen));
2001          jjimageLen = 0;
2002                 image.setLength(image.length() - 2); image.append("\u005c'");
2003          break;
2004       case 44 :
2005          image.append(input_stream.GetSuffix(jjimageLen));
2006          jjimageLen = 0;
2007                 image.setLength(image.length() 2); image.append("\u005c\u005c");
2008          break;
2009       case 45 :
2010          image.append(input_stream.GetSuffix(jjimageLen));
2011          jjimageLen = 0;
2012                String digits = image.substring(image.length() 4, image.length());
2013                image.setLength(image.length() 6);
2014                image.append((char)Integer.parseInt(digits, 16));
2015          break;
2016       default :
2017          break;
2018    }
2019 }
2020 void TokenLexicalActions(Token matchedToken)
2021 {
2022    switch(jjmatchedKind)
2023    {
2024       case 47 :
2025         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
2026         // image.setLength(image.length() - 1);
2027          matchedToken.image = image.toString();
2028          break;
2029       default :
2030          break;
2031    }
2032 }
2033 private void jjCheckNAdd(int state)
2034 {
2035    if (jjrounds[state!= jjround)
2036    {
2037       jjstateSet[jjnewStateCnt++= state;
2038       jjrounds[state= jjround;
2039    }
2040 }
2041 private void jjAddStates(int start, int end)
2042 {
2043    do {
2044       jjstateSet[jjnewStateCnt++= jjnextStates[start];
2045    while (start++ != end);
2046 }
2047 private void jjCheckNAddTwoStates(int state1, int state2)
2048 {
2049    jjCheckNAdd(state1);
2050    jjCheckNAdd(state2);
2051 }
2052 
2053 private void jjCheckNAddStates(int start, int end)
2054 {
2055    do {
2056       jjCheckNAdd(jjnextStates[start]);
2057    while (start++ != end);
2058 }
2059 
2060     /** Constructor. */
2061     public ParseCpslTokenManager(SimpleCharStream stream){
2062 
2063       if (SimpleCharStream.staticFlag)
2064             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2065 
2066     input_stream = stream;
2067   }
2068 
2069   /** Constructor. */
2070   public ParseCpslTokenManager (SimpleCharStream stream, int lexState){
2071     ReInit(stream);
2072     SwitchTo(lexState);
2073   }
2074 
2075   /** Reinitialise parser. */
2076   public void ReInit(SimpleCharStream stream)
2077   {
2078     jjmatchedPos = jjnewStateCnt = 0;
2079     curLexState = defaultLexState;
2080     input_stream = stream;
2081     ReInitRounds();
2082   }
2083 
2084   private void ReInitRounds()
2085   {
2086     int i;
2087     jjround = 0x80000001;
2088     for (i = 64; i-- > 0;)
2089       jjrounds[i0x80000000;
2090   }
2091 
2092   /** Reinitialise parser. */
2093   public void ReInit(SimpleCharStream stream, int lexState)
2094   {
2095     ReInit(stream);
2096     SwitchTo(lexState);
2097   }
2098 
2099   /** Switch to specified lex state. */
2100   public void SwitchTo(int lexState)
2101   {
2102     if (lexState >= || lexState < 0)
2103       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2104     else
2105       curLexState = lexState;
2106   }
2107 
2108 /** Lexer state names. */
2109 public static final String[] lexStateNames = {
2110    "DEFAULT",
2111    "IN_PHASES",
2112    "PHASES_WITHIN_COMMENT",
2113    "IN_STRING",
2114    "WITHIN_COMMENT",
2115 };
2116 
2117 /** Lex State array. */
2118 public static final int[] jjnewLexState = {
2119    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -11, -1, -1, -1, -12, -11, -1, -1, -1, -1, -1
2120    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -13, -1, -1, -1, -1, -1, -1, -1, -1, -1, -10, -1, -1
2121    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -14, -10, -1, -1
2122 };
2123 static final long[] jjtoToken = {
2124    0xfff7800ffff03801L0x181L
2125 };
2126 static final long[] jjtoSkip = {
2127    0xbc000L0x5eL
2128 };
2129 static final long[] jjtoSpecial = {
2130    0xbc000L0x5eL
2131 };
2132 static final long[] jjtoMore = {
2133    0x7ff000040000L0x20L
2134 };
2135     protected SimpleCharStream  input_stream;
2136 
2137     private final int[] jjrounds = new int[64];
2138     private final int[] jjstateSet = new int[64];
2139 
2140     private final StringBuilder jjimage = new StringBuilder();
2141     private StringBuilder image = jjimage;
2142     private int jjimageLen;
2143     private int lengthOfMatch;
2144     
2145     protected char curChar;
2146 }