/* Generated By:JavaCC: Do not edit this line. JavaCCParserTokenManager.java */
package beauty.parsers.javacc;
import java.io.*;
import java.util.*;

/** Token Manager. */
public class JavaCCParserTokenManager implements JavaCCParserConstants
{
    // line buffer, text is accumulated here, then written to the output stream
    // on end of line marker.
    static StringBuffer b = new StringBuffer();
    static StringBuffer outputBuffer = new StringBuffer();
    static ArrayList a = new ArrayList();
    private static OutputStream out = null;
    static int level = 0;
    static int indent = 4;
    static String ls = System.getProperty("line.separator");

    static void reset() {
        b = new StringBuffer();
        outputBuffer = new StringBuffer();
        a.clear();
    }

    static String getText() {
        return outputBuffer.toString();
    }

    static void setLineSeparator(String le) {
        ls = le;
    }

    static void add(Token t) {
        if (t != null) {
            a.add(t);
        }
    }

    static void add(String s) {
        if (s != null) {
            a.add(s);
        }
    }

    static void trim() {
        if (a.size() == 0)
            return;
        Object o = a.get(a.size() - 1);
        StringBuffer sb = new StringBuffer();
        if (o instanceof Token)
            sb.append( ((Token)o).image );
        else
            sb.append((String)o);
        while(sb.length() > 0 && sb.charAt(sb.length() - 1) == ' ')
            sb.deleteCharAt(sb.length() - 1);
        a.set(a.size() - 1, sb.toString() );
    }

    static void trimNL() {
        if(outputBuffer.length() > 0 && outputBuffer.charAt(outputBuffer.length() - 1) == '\u005cn')
            outputBuffer.deleteCharAt(outputBuffer.length() - 1);
        if(outputBuffer.length() > 0 && outputBuffer.charAt(outputBuffer.length() - 1) == '\u005cr')
            outputBuffer.deleteCharAt(outputBuffer.length() - 1);
    }

    static void trimNL(String s) {
        StringBuffer sb = new StringBuffer(s);
        while(sb.length() > 0 && (sb.charAt(sb.length() - 1) == '\u005cr' || sb.charAt(sb.length() - 1) == '\u005cn'))
            sb.deleteCharAt(sb.length() - 1);
    }

    static String trimStart(String s) {
        StringBuffer sb = new StringBuffer(s);
        while(sb.length() > 0
                && (sb.charAt(0) == '\u005cr'
                    || sb.charAt(0) == '\u005cn'
                    || sb.charAt(0) == '\u005ct'
                    || sb.charAt(0) == ' ')) {
            sb.deleteCharAt(0);
        }
        return sb.toString();
    }

    static void trimWhitespace() {
        for (int i = a.size() - 1; i >= 0; i-- ) {
            Object o = a.get(i);
            StringBuffer sb = new StringBuffer();
            if (o instanceof Token)
                sb.append( ((Token)o).image );
            else
                sb.append((String)o);
            while(sb.length() > 0 && (sb.charAt(sb.length() - 1) == '\u005cr'
                    || sb.charAt(sb.length() - 1) == '\u005cn'
                    || sb.charAt(sb.length() - 1) == '\u005ct'
                    || sb.charAt(sb.length() - 1) == ' ')) {
                sb.deleteCharAt(sb.length() - 1);
            }
            if (sb.length() == 0) {
                a.remove(i);
            }
            else {
                a.set(i, sb.toString());
                break;
            }
        }
        if (a.size() == 0) {
            while(outputBuffer.length() > 0 && (outputBuffer.charAt(outputBuffer.length() - 1) == '\u005cr'
                    || outputBuffer.charAt(outputBuffer.length() - 1) == '\u005cn'
                    || outputBuffer.charAt(outputBuffer.length() - 1) == '\u005ct'
                    || outputBuffer.charAt(outputBuffer.length() - 1) == ' ')) {
                outputBuffer.deleteCharAt(outputBuffer.length() - 1);
            }
        }
    }

    static void writeln() {
        write();
        trimNL();
        outputBuffer.append(ls);
    }

    static void write() {
        try {
            b.delete(0, b.length());

            // this next section builds the output string while protecting
            // string literals.  All extra spaces are removed from the output
            // string, except that string literals are left as is.
            ArrayList list = new ArrayList();
            String s = new String("");
            for (int i = 0; i < a.size(); i++) {
                Object o = a.get(i);
                if (o instanceof Token) {
                    Token token = (Token)o;
                    if (token.kind == JavaCCParserConstants.STRING_LITERAL) {
                        s = s.replaceAll("[ ]+", " ");
                        list.add(s);
                        s = new String("");
                        list.add(token.image);
                    }
                    else {
                        s += ((Token)o).image;
                        s = s.replaceAll("[ ]+", " ");
                    }
                }
                else {
                    s += (String)o;
                    s = s.replaceAll("[ ]+", " ");
                }
            }
            for (int i = 0; i < list.size(); i++) {
                b.append((String)list.get(i));
            }

            b.append(s);
            s = b.toString();

            // check for blank lines
            String maybe_blank = new String(s);
            if (maybe_blank.trim().length() == 0) {
                // yep, it's a blank, so just print it out
                if (s.length() >= ls.length()) {
                    s = s.substring(0, s.length() - ls.length());
                }
                outputBuffer.append(s);
                a.clear();
                return;
            }

            // most lines get indented, but there are a few special cases:
            // "else" gets put on the same line as the closing "}" for the "if",
            // so don't want to indent.  Similarly with "catch" and "finally".
            // The "while" at the end of a "do" loop is marked as "^while" to
            // differentiate it from a regular "while" block.  I'm also doing
            // some special handling if the line starts with "|", those lines
            // are indented 2 spaces less than the preceding line, this helps
            // keep the "|"s off of the same column as the various brackets and
            // makes them easier to see.
            if (!s.startsWith(" else")
                    && !s.startsWith(" catch")
                    && !s.startsWith(" finally")
                    && !s.startsWith(" ^while")
                    && !s.startsWith(" {")
                    && (!endsWith(outputBuffer, "else") && !endsWith(outputBuffer, "else "))) {
                s = s.trim();
                boolean has_or = s.startsWith("|");
                for (int i = 0; i < level; i++) {
                    s = "    " + s;
                }
                if (has_or && s.startsWith("  ")) {
                    s = s.substring(2);
                }
            }

            // maybe clean out the ^ from the specially marked "while" at the
            // end of a "do" loop
            if (s.startsWith(" ^while")) {
                b.deleteCharAt(1);
                s = b.toString();
            }

            // remove any line enders
            //trimNL(s);

            // check if the output buffer does NOT end with a new line.  If it
            // doesn't, remove any leading whitespace from this line -- this means
            // that a partial line was previously written, and this line needs
            // to continue on the same line rather than a new line
            if (!endsWith(outputBuffer, "\u005cn") && !endsWith(outputBuffer, "\u005cr")) {
                s = trimStart(s);
            }

            // check that there aren't extra spaces in the buffer already
            if (s.startsWith(" ") && endsWith(outputBuffer, " ")) {
                s = s.substring(1);
            }

            // check that there is one space between the end of the output
            // buffer and this line
            if (!s.startsWith(" ")
                    && !endsWith(outputBuffer, " ")
                    && !endsWith(outputBuffer, "\u005cr")
                    && !endsWith(outputBuffer, "\u005cn")
                    && outputBuffer.length() > 0) {
                outputBuffer.append(" ");
            }

            // finally! add the string
            outputBuffer.append(s);

            // clear the accumulator for the next line
            a.clear();
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }

    static boolean endsWith(StringBuffer sb, String s) {
        if (sb == null && s == null)
            return true;
        if (sb == null && sb != null)
            return false;
        if (sb.length() < s.length())
            return false;
        String end = sb.substring(sb.length() - s.length());
        return end.equals(s);
    }

    static void writeComment(String s) {
        String[] lines = s.split("\u005cr\u005cn|\u005cr|\u005cn");
        for (int i = 0; i < lines.length; i++) {
            String line = lines[i];
            line = line.trim();

            if (line.startsWith("*")) {
                line = " " + line;
            }

            for (int j = 0; j < level; j++) {
                line = "    " + line;
            }
            outputBuffer.append(line).append(ls);
        }
    }

  /** Debug output. */
  public  java.io.PrintStream debugStream = System.out;
  /** Set debug output. */
  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
{
   switch (pos)
   {
      case 0:
         if ((active0 & 0x1fffffffffffff00L) != 0L)
         {
            jjmatchedKind = 69;
            return 38;
         }
         if ((active1 & 0x100800000000L) != 0L)
            return 59;
         if ((active1 & 0x10000000010000L) != 0L)
            return 9;
         return -1;
      case 1:
         if ((active0 & 0x80300000L) != 0L)
            return 38;
         if ((active0 & 0x1fffffff7fcfff00L) != 0L)
         {
            if (jjmatchedPos != 1)
            {
               jjmatchedKind = 69;
               jjmatchedPos = 1;
            }
            return 38;
         }
         return -1;
      case 2:
         if ((active0 & 0x200009820000000L) != 0L)
            return 38;
         if ((active0 & 0x1dffff675fefff00L) != 0L)
         {
            if (jjmatchedPos != 2)
            {
               jjmatchedKind = 69;
               jjmatchedPos = 2;
            }
            return 38;
         }
         return -1;
      case 3:
         if ((active0 & 0x18effe571f2f4f00L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 3;
            return 38;
         }
         if ((active0 & 0x510012040c0b000L) != 0L)
            return 38;
         return -1;
      case 4:
         if ((active0 & 0x106240001e034800L) != 0L)
            return 38;
         if ((active0 & 0x88dbe57012c0700L) != 0L)
         {
            if (jjmatchedPos != 4)
            {
               jjmatchedKind = 69;
               jjmatchedPos = 4;
            }
            return 38;
         }
         return -1;
      case 5:
         if ((active0 & 0x44b04200200200L) != 0L)
            return 38;
         if ((active0 & 0x8890e15090c0500L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 5;
            return 38;
         }
         return -1;
      case 6:
         if ((active0 & 0x889081500040100L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 6;
            return 38;
         }
         if ((active0 & 0x60009080400L) != 0L)
            return 38;
         return -1;
      case 7:
         if ((active0 & 0x801000000040100L) != 0L)
            return 38;
         if ((active0 & 0x88081500000000L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 7;
            return 38;
         }
         return -1;
      case 8:
         if ((active0 & 0x80081000000000L) != 0L)
            return 38;
         if ((active0 & 0x8000500000000L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 8;
            return 38;
         }
         return -1;
      case 9:
         if ((active0 & 0x500000000L) != 0L)
            return 38;
         if ((active0 & 0x8000000000000L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 9;
            return 38;
         }
         return -1;
      case 10:
         if ((active0 & 0x8000000000000L) != 0L)
         {
            jjmatchedKind = 69;
            jjmatchedPos = 10;
            return 38;
         }
         return -1;
      default :
         return -1;
   }
}
private final int jjStartNfa_0(int pos, long active0, long active1)
{
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
}
private int jjStopAtPos(int pos, int kind)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   return pos + 1;
}
private int jjMoveStringLiteralDfa0_0()
{
   switch(curChar)
   {
      case 33:
         jjmatchedKind = 84;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);
      case 35:
         return jjStopAtPos(0, 120);
      case 37:
         jjmatchedKind = 103;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L);
      case 38:
         jjmatchedKind = 100;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x200020000000L);
      case 40:
         return jjStopAtPos(0, 72);
      case 41:
         return jjStopAtPos(0, 73);
      case 42:
         jjmatchedKind = 98;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000L);
      case 43:
         jjmatchedKind = 96;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x20040000000L);
      case 44:
         return jjStopAtPos(0, 79);
      case 45:
         jjmatchedKind = 97;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x40080000000L);
      case 46:
         jjmatchedKind = 80;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
      case 47:
         jjmatchedKind = 99;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000L);
      case 58:
         return jjStopAtPos(0, 87);
      case 59:
         return jjStopAtPos(0, 78);
      case 60:
         jjmatchedKind = 83;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x2010002000000L);
      case 61:
         jjmatchedKind = 82;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000L);
      case 62:
         jjmatchedKind = 119;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x6c000004000000L);
      case 63:
         return jjStopAtPos(0, 86);
      case 64:
         return jjStopAtPos(0, 81);
      case 91:
         return jjStopAtPos(0, 76);
      case 93:
         return jjStopAtPos(0, 77);
      case 94:
         jjmatchedKind = 102;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
      case 97:
         return jjMoveStringLiteralDfa1_0(0x300L, 0x0L);
      case 98:
         return jjMoveStringLiteralDfa1_0(0x1c00L, 0x0L);
      case 99:
         return jjMoveStringLiteralDfa1_0(0x7e000L, 0x0L);
      case 100:
         return jjMoveStringLiteralDfa1_0(0x380000L, 0x0L);
      case 101:
         return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
      case 102:
         return jjMoveStringLiteralDfa1_0(0x3e000000L, 0x0L);
      case 103:
         return jjMoveStringLiteralDfa1_0(0x40000000L, 0x0L);
      case 105:
         return jjMoveStringLiteralDfa1_0(0x1f80000000L, 0x0L);
      case 108:
         return jjMoveStringLiteralDfa1_0(0x2000000000L, 0x0L);
      case 110:
         return jjMoveStringLiteralDfa1_0(0x1c000000000L, 0x0L);
      case 112:
         return jjMoveStringLiteralDfa1_0(0x1e0000000000L, 0x0L);
      case 114:
         return jjMoveStringLiteralDfa1_0(0x200000000000L, 0x0L);
      case 115:
         return jjMoveStringLiteralDfa1_0(0xfc00000000000L, 0x0L);
      case 116:
         return jjMoveStringLiteralDfa1_0(0x3f0000000000000L, 0x0L);
      case 118:
         return jjMoveStringLiteralDfa1_0(0xc00000000000000L, 0x0L);
      case 119:
         return jjMoveStringLiteralDfa1_0(0x1000000000000000L, 0x0L);
      case 123:
         return jjStopAtPos(0, 74);
      case 124:
         jjmatchedKind = 101;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x400010000000L);
      case 125:
         return jjStopAtPos(0, 75);
      case 126:
         return jjStopAtPos(0, 85);
      default :
         return jjMoveNfa_0(5, 0);
   }
}
private int jjMoveStringLiteralDfa1_0(long active0, long active1)
{
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0, active1);
      return 1;
   }
   switch(curChar)
   {
      case 38:
         if ((active1 & 0x20000000L) != 0L)
            return jjStopAtPos(1, 93);
         break;
      case 43:
         if ((active1 & 0x40000000L) != 0L)
            return jjStopAtPos(1, 94);
         break;
      case 45:
         if ((active1 & 0x80000000L) != 0L)
            return jjStopAtPos(1, 95);
         break;
      case 46:
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000000000L);
      case 60:
         if ((active1 & 0x10000000000L) != 0L)
         {
            jjmatchedKind = 104;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2000000000000L);
      case 61:
         if ((active1 & 0x1000000L) != 0L)
            return jjStopAtPos(1, 88);
         else if ((active1 & 0x2000000L) != 0L)
            return jjStopAtPos(1, 89);
         else if ((active1 & 0x4000000L) != 0L)
            return jjStopAtPos(1, 90);
         else if ((active1 & 0x8000000L) != 0L)
            return jjStopAtPos(1, 91);
         else if ((active1 & 0x20000000000L) != 0L)
            return jjStopAtPos(1, 105);
         else if ((active1 & 0x40000000000L) != 0L)
            return jjStopAtPos(1, 106);
         else if ((active1 & 0x80000000000L) != 0L)
            return jjStopAtPos(1, 107);
         else if ((active1 & 0x100000000000L) != 0L)
            return jjStopAtPos(1, 108);
         else if ((active1 & 0x200000000000L) != 0L)
            return jjStopAtPos(1, 109);
         else if ((active1 & 0x400000000000L) != 0L)
            return jjStopAtPos(1, 110);
         else if ((active1 & 0x800000000000L) != 0L)
            return jjStopAtPos(1, 111);
         else if ((active1 & 0x1000000000000L) != 0L)
            return jjStopAtPos(1, 112);
         break;
      case 62:
         if ((active1 & 0x40000000000000L) != 0L)
         {
            jjmatchedKind = 118;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2c000000000000L);
      case 97:
         return jjMoveStringLiteralDfa2_0(active0, 0x24002006000L, active1, 0L);
      case 98:
         return jjMoveStringLiteralDfa2_0(active0, 0x100L, active1, 0L);
      case 101:
         return jjMoveStringLiteralDfa2_0(active0, 0x208000080000L, active1, 0L);
      case 102:
         if ((active0 & 0x80000000L) != 0L)
            return jjStartNfaWithStates_0(1, 31, 38);
         break;
      case 104:
         return jjMoveStringLiteralDfa2_0(active0, 0x1070400000008000L, active1, 0L);
      case 105:
         return jjMoveStringLiteralDfa2_0(active0, 0xc000000L, active1, 0L);
      case 108:
         return jjMoveStringLiteralDfa2_0(active0, 0x10410000L, active1, 0L);
      case 109:
         return jjMoveStringLiteralDfa2_0(active0, 0x300000000L, active1, 0L);
      case 110:
         return jjMoveStringLiteralDfa2_0(active0, 0x1c00800000L, active1, 0L);
      case 111:
         if ((active0 & 0x100000L) != 0L)
         {
            jjmatchedKind = 20;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0xc00002060260400L, active1, 0L);
      case 114:
         return jjMoveStringLiteralDfa2_0(active0, 0x3800c0000000800L, active1, 0L);
      case 115:
         return jjMoveStringLiteralDfa2_0(active0, 0x200L, active1, 0L);
      case 116:
         return jjMoveStringLiteralDfa2_0(active0, 0x1800000000000L, active1, 0L);
      case 117:
         return jjMoveStringLiteralDfa2_0(active0, 0x2110000000000L, active1, 0L);
      case 119:
         return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L, active1, 0L);
      case 120:
         return jjMoveStringLiteralDfa2_0(active0, 0x1000000L, active1, 0L);
      case 121:
         return jjMoveStringLiteralDfa2_0(active0, 0x8000000001000L, active1, 0L);
      case 124:
         if ((active1 & 0x10000000L) != 0L)
            return jjStopAtPos(1, 92);
         break;
      default :
         break;
   }
   return jjStartNfa_0(0, active0, active1);
}
private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(0, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(1, active0, active1);
      return 2;
   }
   switch(curChar)
   {
      case 46:
         if ((active1 & 0x10000000000000L) != 0L)
            return jjStopAtPos(2, 116);
         break;
      case 61:
         if ((active1 & 0x2000000000000L) != 0L)
            return jjStopAtPos(2, 113);
         else if ((active1 & 0x4000000000000L) != 0L)
            return jjStopAtPos(2, 114);
         break;
      case 62:
         if ((active1 & 0x20000000000000L) != 0L)
         {
            jjmatchedKind = 117;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000000000L);
      case 97:
         return jjMoveStringLiteralDfa3_0(active0, 0x80800000018000L, active1, 0L);
      case 98:
         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L);
      case 99:
         return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L, active1, 0L);
      case 101:
         return jjMoveStringLiteralDfa3_0(active0, 0x800L, active1, 0L);
      case 102:
         return jjMoveStringLiteralDfa3_0(active0, 0x80000L, active1, 0L);
      case 105:
         return jjMoveStringLiteralDfa3_0(active0, 0x1414040000000000L, active1, 0L);
      case 108:
         return jjMoveStringLiteralDfa3_0(active0, 0x800010002000000L, active1, 0L);
      case 110:
         return jjMoveStringLiteralDfa3_0(active0, 0x800200c060000L, active1, 0L);
      case 111:
         return jjMoveStringLiteralDfa3_0(active0, 0x480010000400L, active1, 0L);
      case 112:
         return jjMoveStringLiteralDfa3_0(active0, 0x2000300000000L, active1, 0L);
      case 114:
         if ((active0 & 0x20000000L) != 0L)
            return jjStartNfaWithStates_0(2, 29, 38);
         return jjMoveStringLiteralDfa3_0(active0, 0x61000000000000L, active1, 0L);
      case 115:
         return jjMoveStringLiteralDfa3_0(active0, 0x400402300L, active1, 0L);
      case 116:
         if ((active0 & 0x800000000L) != 0L)
         {
            jjmatchedKind = 35;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0x205041005000L, active1, 0L);
      case 117:
         return jjMoveStringLiteralDfa3_0(active0, 0x100000000a00000L, active1, 0L);
      case 119:
         if ((active0 & 0x8000000000L) != 0L)
            return jjStartNfaWithStates_0(2, 39, 38);
         break;
      case 121:
         if ((active0 & 0x200000000000000L) != 0L)
            return jjStartNfaWithStates_0(2, 57, 38);
         break;
      default :
         break;
   }
   return jjStartNfa_0(1, active0, active1);
}
private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(1, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0, active1);
      return 3;
   }
   switch(curChar)
   {
      case 61:
         if ((active1 & 0x8000000000000L) != 0L)
            return jjStopAtPos(3, 115);
         break;
      case 97:
         return jjMoveStringLiteralDfa4_0(active0, 0x80000001c080800L, active1, 0L);
      case 98:
         return jjMoveStringLiteralDfa4_0(active0, 0x200000L, active1, 0L);
      case 99:
         return jjMoveStringLiteralDfa4_0(active0, 0x8000000004000L, active1, 0L);
      case 100:
         if ((active0 & 0x400000000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 58, 38);
         break;
      case 101:
         if ((active0 & 0x1000L) != 0L)
            return jjStartNfaWithStates_0(3, 12, 38);
         else if ((active0 & 0x2000L) != 0L)
            return jjStartNfaWithStates_0(3, 13, 38);
         else if ((active0 & 0x400000L) != 0L)
            return jjStartNfaWithStates_0(3, 22, 38);
         else if ((active0 & 0x100000000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 56, 38);
         return jjMoveStringLiteralDfa4_0(active0, 0x2001001000200L, active1, 0L);
      case 103:
         if ((active0 & 0x2000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 37, 38);
         break;
      case 105:
         return jjMoveStringLiteralDfa4_0(active0, 0x1004000000000L, active1, 0L);
      case 107:
         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L);
      case 108:
         if ((active0 & 0x10000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 40, 38);
         return jjMoveStringLiteralDfa4_0(active0, 0x1000100100000400L, active1, 0L);
      case 109:
         if ((active0 & 0x800000L) != 0L)
            return jjStartNfaWithStates_0(3, 23, 38);
         break;
      case 110:
         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0L);
      case 111:
         if ((active0 & 0x40000000L) != 0L)
            return jjStartNfaWithStates_0(3, 30, 38);
         return jjMoveStringLiteralDfa4_0(active0, 0x60000200000000L, active1, 0L);
      case 114:
         if ((active0 & 0x8000L) != 0L)
            return jjStartNfaWithStates_0(3, 15, 38);
         return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L);
      case 115:
         if ((active0 & 0x10000000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 52, 38);
         return jjMoveStringLiteralDfa4_0(active0, 0x2030000L, active1, 0L);
      case 116:
         return jjMoveStringLiteralDfa4_0(active0, 0x4880400040100L, active1, 0L);
      case 117:
         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
      case 118:
         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L, active1, 0L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0, active1);
}
private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
{
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
      return jjStartNfa_0(2, old0, old1);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(3, active0, 0L);
      return 4;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa5_0(active0, 0x60400000000L);
      case 99:
         return jjMoveStringLiteralDfa5_0(active0, 0x5000000000000L);
      case 101:
         if ((active0 & 0x2000000L) != 0L)
            return jjStartNfaWithStates_0(4, 25, 38);
         else if ((active0 & 0x1000000000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 60, 38);
         return jjMoveStringLiteralDfa5_0(active0, 0x80100000400L);
      case 104:
         if ((active0 & 0x4000L) != 0L)
            return jjStartNfaWithStates_0(4, 14, 38);
         return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L);
      case 105:
         return jjMoveStringLiteralDfa5_0(active0, 0x900000040000L);
      case 107:
         if ((active0 & 0x800L) != 0L)
            return jjStartNfaWithStates_0(4, 11, 38);
         break;
      case 108:
         if ((active0 & 0x4000000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 4;
         }
         return jjMoveStringLiteralDfa5_0(active0, 0x8200000L);
      case 110:
         return jjMoveStringLiteralDfa5_0(active0, 0x1000000L);
      case 114:
         if ((active0 & 0x2000000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 49, 38);
         return jjMoveStringLiteralDfa5_0(active0, 0x201200000300L);
      case 115:
         if ((active0 & 0x10000L) != 0L)
            return jjStartNfaWithStates_0(4, 16, 38);
         return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
      case 116:
         if ((active0 & 0x20000L) != 0L)
            return jjStartNfaWithStates_0(4, 17, 38);
         else if ((active0 & 0x10000000L) != 0L)
            return jjStartNfaWithStates_0(4, 28, 38);
         else if ((active0 & 0x400000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 46, 38);
         return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L);
      case 117:
         return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
      case 118:
         return jjMoveStringLiteralDfa5_0(active0, 0x4000000000L);
      case 119:
         if ((active0 & 0x20000000000000L) != 0L)
         {
            jjmatchedKind = 53;
            jjmatchedPos = 4;
         }
         return jjMoveStringLiteralDfa5_0(active0, 0x40000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(3, active0, 0L);
}
private int jjMoveStringLiteralDfa5_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(3, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(4, active0, 0L);
      return 5;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa6_0(active0, 0x500L);
      case 99:
         if ((active0 & 0x100000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 44, 38);
         else if ((active0 & 0x800000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 47, 38);
         return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
      case 100:
         return jjMoveStringLiteralDfa6_0(active0, 0x1000000L);
      case 101:
         if ((active0 & 0x200000L) != 0L)
            return jjStartNfaWithStates_0(5, 21, 38);
         else if ((active0 & 0x4000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 38, 38);
         break;
      case 102:
         return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L);
      case 103:
         return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L);
      case 104:
         if ((active0 & 0x4000000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 50, 38);
         break;
      case 105:
         return jjMoveStringLiteralDfa6_0(active0, 0x880000000000000L);
      case 108:
         return jjMoveStringLiteralDfa6_0(active0, 0x8080000L);
      case 109:
         return jjMoveStringLiteralDfa6_0(active0, 0x100000000L);
      case 110:
         if ((active0 & 0x200000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 45, 38);
         return jjMoveStringLiteralDfa6_0(active0, 0x400040000L);
      case 114:
         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L);
      case 115:
         if ((active0 & 0x40000000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 54, 38);
         break;
      case 116:
         if ((active0 & 0x200L) != 0L)
            return jjStartNfaWithStates_0(5, 9, 38);
         else if ((active0 & 0x200000000L) != 0L)
            return jjStartNfaWithStates_0(5, 33, 38);
         return jjMoveStringLiteralDfa6_0(active0, 0x1040000000000L);
      default :
         break;
   }
   return jjStartNfa_0(4, active0, 0L);
}
private int jjMoveStringLiteralDfa6_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(4, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(5, active0, 0L);
      return 6;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000L);
      case 99:
         return jjMoveStringLiteralDfa7_0(active0, 0x400000100L);
      case 101:
         if ((active0 & 0x20000000000L) != 0L)
            return jjStartNfaWithStates_0(6, 41, 38);
         else if ((active0 & 0x40000000000L) != 0L)
            return jjStartNfaWithStates_0(6, 42, 38);
         return jjMoveStringLiteralDfa7_0(active0, 0x80000100000000L);
      case 102:
         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L);
      case 108:
         return jjMoveStringLiteralDfa7_0(active0, 0x800000000000000L);
      case 110:
         if ((active0 & 0x400L) != 0L)
            return jjStartNfaWithStates_0(6, 10, 38);
         break;
      case 111:
         return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L);
      case 115:
         if ((active0 & 0x1000000L) != 0L)
            return jjStartNfaWithStates_0(6, 24, 38);
         break;
      case 116:
         if ((active0 & 0x80000L) != 0L)
            return jjStartNfaWithStates_0(6, 19, 38);
         return jjMoveStringLiteralDfa7_0(active0, 0x80000000000L);
      case 117:
         return jjMoveStringLiteralDfa7_0(active0, 0x40000L);
      case 121:
         if ((active0 & 0x8000000L) != 0L)
            return jjStartNfaWithStates_0(6, 27, 38);
         break;
      default :
         break;
   }
   return jjStartNfa_0(5, active0, 0L);
}
private int jjMoveStringLiteralDfa7_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(5, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(6, active0, 0L);
      return 7;
   }
   switch(curChar)
   {
      case 99:
         return jjMoveStringLiteralDfa8_0(active0, 0x1000000000L);
      case 101:
         if ((active0 & 0x40000L) != 0L)
            return jjStartNfaWithStates_0(7, 18, 38);
         else if ((active0 & 0x800000000000000L) != 0L)
            return jjStartNfaWithStates_0(7, 59, 38);
         return jjMoveStringLiteralDfa8_0(active0, 0x80400000000L);
      case 110:
         return jjMoveStringLiteralDfa8_0(active0, 0x88000100000000L);
      case 112:
         if ((active0 & 0x1000000000000L) != 0L)
            return jjStartNfaWithStates_0(7, 48, 38);
         break;
      case 116:
         if ((active0 & 0x100L) != 0L)
            return jjStartNfaWithStates_0(7, 8, 38);
         break;
      default :
         break;
   }
   return jjStartNfa_0(6, active0, 0L);
}
private int jjMoveStringLiteralDfa8_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(6, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(7, active0, 0L);
      return 8;
   }
   switch(curChar)
   {
      case 100:
         if ((active0 & 0x80000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 43, 38);
         break;
      case 101:
         if ((active0 & 0x1000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 36, 38);
         break;
      case 105:
         return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000L);
      case 111:
         return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
      case 116:
         if ((active0 & 0x80000000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 55, 38);
         return jjMoveStringLiteralDfa9_0(active0, 0x100000000L);
      default :
         break;
   }
   return jjStartNfa_0(7, active0, 0L);
}
private int jjMoveStringLiteralDfa9_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(7, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(8, active0, 0L);
      return 9;
   }
   switch(curChar)
   {
      case 102:
         if ((active0 & 0x400000000L) != 0L)
            return jjStartNfaWithStates_0(9, 34, 38);
         break;
      case 115:
         if ((active0 & 0x100000000L) != 0L)
            return jjStartNfaWithStates_0(9, 32, 38);
         break;
      case 122:
         return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(8, active0, 0L);
}
private int jjMoveStringLiteralDfa10_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(8, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(9, active0, 0L);
      return 10;
   }
   switch(curChar)
   {
      case 101:
         return jjMoveStringLiteralDfa11_0(active0, 0x8000000000000L);
      default :
         break;
   }
   return jjStartNfa_0(9, active0, 0L);
}
private int jjMoveStringLiteralDfa11_0(long old0, long active0)
{
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(9, old0, 0L);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(10, active0, 0L);
      return 11;
   }
   switch(curChar)
   {
      case 100:
         if ((active0 & 0x8000000000000L) != 0L)
            return jjStartNfaWithStates_0(11, 51, 38);
         break;
      default :
         break;
   }
   return jjStartNfa_0(10, active0, 0L);
}
private int jjStartNfaWithStates_0(int pos, int kind, int state)
{
   jjmatchedKind = kind;
   jjmatchedPos = pos;
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) { return pos + 1; }
   return jjMoveNfa_0(state, pos + 1);
}
static final long[] jjbitVec0 = {
   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec1 = {
   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
};
static final long[] jjbitVec3 = {
   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
};
static final long[] jjbitVec4 = {
   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
};
static final long[] jjbitVec5 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
};
static final long[] jjbitVec6 = {
   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
};
static final long[] jjbitVec7 = {
   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
};
private int jjMoveNfa_0(int startState, int curPos)
{
   int startsAt = 0;
   jjnewStateCnt = 77;
   int i = 1;
   jjstateSet[0] = startState;
   int kind = 0x7fffffff;
   for (;;)
   {
      if (++jjround == 0x7fffffff)
         ReInitRounds();
      if (curChar < 64)
      {
         long l = 1L << curChar;
         do
         {
            switch(jjstateSet[--i])
            {
               case 5:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddStates(0, 6);
                  else if ((0x2400L & l) != 0L)
                  {
                     if (kind > 2)
                        kind = 2;
                     jjCheckNAddTwoStates(0, 2);
                  }
                  else if (curChar == 47)
                     jjAddStates(7, 9);
                  else if (curChar == 36)
                  {
                     if (kind > 69)
                        kind = 69;
                     jjCheckNAdd(38);
                  }
                  else if (curChar == 34)
                     jjCheckNAddStates(10, 12);
                  else if (curChar == 39)
                     jjAddStates(13, 14);
                  else if (curChar == 46)
                     jjCheckNAdd(9);
                  else if (curChar == 9)
                  {
                     if (kind > 4)
                        kind = 4;
                     jjCheckNAdd(4);
                  }
                  else if (curChar == 32)
                  {
                     if (kind > 3)
                        kind = 3;
                     jjCheckNAdd(3);
                  }
                  if ((0x3fe000000000000L & l) != 0L)
                  {
                     if (kind > 61)
                        kind = 61;
                     jjCheckNAddTwoStates(6, 7);
                  }
                  else if (curChar == 48)
                  {
                     if (kind > 61)
                        kind = 61;
                     jjCheckNAddStates(15, 17);
                  }
                  else if (curChar == 13)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 59:
                  if (curChar == 42)
                     jjCheckNAddTwoStates(72, 73);
                  else if (curChar == 47)
                  {
                     if (kind > 5)
                        kind = 5;
                     jjCheckNAddStates(18, 20);
                  }
                  if (curChar == 42)
                     jjstateSet[jjnewStateCnt++] = 64;
                  break;
               case 0:
                  if ((0x2400L & l) == 0L)
                     break;
                  if (kind > 2)
                     kind = 2;
                  jjCheckNAddTwoStates(0, 2);
                  break;
               case 1:
                  if (curChar != 10)
                     break;
                  if (kind > 2)
                     kind = 2;
                  jjCheckNAddTwoStates(0, 2);
                  break;
               case 2:
                  if (curChar == 13)
                     jjstateSet[jjnewStateCnt++] = 1;
                  break;
               case 3:
                  if (curChar != 32)
                     break;
                  if (kind > 3)
                     kind = 3;
                  jjCheckNAdd(3);
                  break;
               case 4:
                  if (curChar != 9)
                     break;
                  if (kind > 4)
                     kind = 4;
                  jjCheckNAdd(4);
                  break;
               case 6:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 61)
                     kind = 61;
                  jjCheckNAddTwoStates(6, 7);
                  break;
               case 8:
                  if (curChar == 46)
                     jjCheckNAdd(9);
                  break;
               case 9:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 65)
                     kind = 65;
                  jjCheckNAddStates(21, 23);
                  break;
               case 11:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(12);
                  break;
               case 12:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 65)
                     kind = 65;
                  jjCheckNAddTwoStates(12, 13);
                  break;
               case 14:
                  if (curChar == 39)
                     jjAddStates(13, 14);
                  break;
               case 15:
                  if ((0xffffff7fffffdbffL & l) != 0L)
                     jjCheckNAdd(16);
                  break;
               case 16:
                  if (curChar == 39 && kind > 67)
                     kind = 67;
                  break;
               case 19:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 20;
                  break;
               case 20:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 21;
                  break;
               case 21:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 22;
                  break;
               case 22:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAdd(16);
                  break;
               case 23:
                  if ((0x8400000000L & l) != 0L)
                     jjCheckNAdd(16);
                  break;
               case 24:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(25, 16);
                  break;
               case 25:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAdd(16);
                  break;
               case 26:
                  if ((0xf000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 27;
                  break;
               case 27:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAdd(25);
                  break;
               case 28:
                  if (curChar == 34)
                     jjCheckNAddStates(10, 12);
                  break;
               case 29:
                  if ((0xfffffffbffffdbffL & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 31:
                  if ((0x8400000000L & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 32:
                  if (curChar == 34 && kind > 68)
                     kind = 68;
                  break;
               case 33:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAddStates(24, 27);
                  break;
               case 34:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAddStates(10, 12);
                  break;
               case 35:
                  if ((0xf000000000000L & l) != 0L)
                     jjstateSet[jjnewStateCnt++] = 36;
                  break;
               case 36:
                  if ((0xff000000000000L & l) != 0L)
                     jjCheckNAdd(34);
                  break;
               case 37:
                  if (curChar != 36)
                     break;
                  if (kind > 69)
                     kind = 69;
                  jjCheckNAdd(38);
                  break;
               case 38:
                  if ((0x3ff001000000000L & l) == 0L)
                     break;
                  if (kind > 69)
                     kind = 69;
                  jjCheckNAdd(38);
                  break;
               case 39:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddStates(0, 6);
                  break;
               case 40:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(40, 41);
                  break;
               case 41:
                  if (curChar != 46)
                     break;
                  if (kind > 65)
                     kind = 65;
                  jjCheckNAddStates(28, 30);
                  break;
               case 42:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 65)
                     kind = 65;
                  jjCheckNAddStates(28, 30);
                  break;
               case 44:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(45);
                  break;
               case 45:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 65)
                     kind = 65;
                  jjCheckNAddTwoStates(45, 13);
                  break;
               case 46:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(46, 47);
                  break;
               case 48:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(49);
                  break;
               case 49:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 65)
                     kind = 65;
                  jjCheckNAddTwoStates(49, 13);
                  break;
               case 50:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddStates(31, 33);
                  break;
               case 52:
                  if ((0x280000000000L & l) != 0L)
                     jjCheckNAdd(53);
                  break;
               case 53:
                  if ((0x3ff000000000000L & l) != 0L)
                     jjCheckNAddTwoStates(53, 13);
                  break;
               case 54:
                  if (curChar != 48)
                     break;
                  if (kind > 61)
                     kind = 61;
                  jjCheckNAddStates(15, 17);
                  break;
               case 56:
                  if ((0x3ff000000000000L & l) == 0L)
                     break;
                  if (kind > 61)
                     kind = 61;
                  jjCheckNAddTwoStates(56, 7);
                  break;
               case 57:
                  if ((0xff000000000000L & l) == 0L)
                     break;
                  if (kind > 61)
                     kind = 61;
                  jjCheckNAddTwoStates(57, 7);
                  break;
               case 58:
                  if (curChar == 47)
                     jjAddStates(7, 9);
                  break;
               case 60:
                  if ((0xffffffffffffdbffL & l) == 0L)
                     break;
                  if (kind > 5)
                     kind = 5;
                  jjCheckNAddStates(18, 20);
                  break;
               case 61:
                  if ((0x2400L & l) != 0L && kind > 5)
                     kind = 5;
                  break;
               case 62:
                  if (curChar == 10 && kind > 5)
                     kind = 5;
                  break;
               case 63:
                  if (curChar == 13)
                     jjstateSet[jjnewStateCnt++] = 62;…