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

/** Token Manager. */
public class BSHParserTokenManager implements BSHParserConstants
{
    // line buffer, text is accumulated here, then written to the output stream
    // on end of line marker.
    static StringBuilder b = new StringBuilder();

    // all text is accumulated here.  When processing is complete, this buffer
    // will contain the final beautified text.
    static StringBuilder outputBuffer = new StringBuilder();

    // accumulate pieces a token or string at a time.  The objects in this array
    // will be ocnverted to strings, padded as appropriate, and added to the
    // line buffer b.  This is the "accumulator".
    static ArrayList a = new ArrayList();

    // where to write the completely beautified code.
    private static PrintWriter out = null;

    // level of indentation
    static int level = 0;

    // width of indent
    static int indent_width = 4;
    static String indent = "    ";
    static String double_indent = indent + indent;

    // the soft tab setting from jEdit, use soft tabs by default.
    static boolean useSoftTabs = true;

    // line separator, defaults to system line separator, but can be set to
    // a specific separator
    static String ls = System.getProperty("line.separator");

    static void reset() {
        b = new StringBuilder();
        outputBuffer = new StringBuilder();
        a.clear();
        level = 0;
    }

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

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

    static void setIndentWidth(int w) {
        indent_width = w;
        if (indent_width <= 0) {
            indent_width = 4;
        }
        indent = "";
        for (int i = 0; i < w; i++) {
            indent += " ";
        }
        double_indent = indent + indent;
    }

    static void setUseSoftTabs(boolean b) {
        useSoftTabs = b;
        if (b) {
            indent = "\u005ct";
            double_indent = "\u005ct\u005ct";
        }
        else {
            setIndentWidth(indent_width);
        }
    }

    // add a token to the accumulator
    static void add(Token t) {
        if (t != null) {
            a.add(t);
        }
    }

    // add a string to the accumulator
    static void add(String s) {
        if (s != null) {
            a.add(s);
        }
    }

    // trim spaces from the last item in the accumulator
    static void trim() {
        if (a.size() == 0)
            return;
        Object o = a.get(a.size() - 1);
        StringBuilder sb = new StringBuilder();
        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() );
    }

    // trim a single new line from the end of the output buffer
    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);
    }

    // trim all \n and/or \r from the end of the given string
    static void trimNL(String s) {
        StringBuilder sb = new StringBuilder(s);
        while(sb.length() > 0 && (sb.charAt(sb.length() - 1) == '\u005cr' || sb.charAt(sb.length() - 1) == '\u005cn'))
            sb.deleteCharAt(sb.length() - 1);
    }

    // trim all whitespace (\r, \n, space, \t) from the start of the given string
    static String trimStart(String s) {
        StringBuilder sb = new StringBuilder(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();
    }

    // trim up to max whitespace (\r, \n, space, \t) from the start of the given string
    static String trimStart(String s, int max) {
        StringBuilder sb = new StringBuilder(s);
        int trimmed = 0;
        while(sb.length() > 0 && Character.isWhitespace(sb.charAt(0)) && trimmed < max) {
            sb.deleteCharAt(0);
            ++trimmed;
        }
        return sb.toString();
    }

    // trims whitespace (\r, \n, space, \t) from the last items in the
    // accumulator.  If the last item is all whitespace, continues on to the
    // previous until a non-whitespace character is encountered.  If the
    // entire accumulator is whitespace, continues to trim whitespace from the
    // outputBuffer.
    static void trimWhitespace() {
        for (int i = a.size() - 1; i >= 0; i-- ) {
            Object o = a.get(i);
            StringBuilder sb = new StringBuilder();
            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);
            }
        }
    }

    // writes the contents of the accumulator to the outputBuffer.  The line
    // buffer (b) is used to build the line.
    static void write() {
        try {
            b.setLength(0); // clear the line buffer

            // 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 == BSHParserConstants.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 line(s)
            String maybe_blank = new String(s);
            if (maybe_blank.trim().isEmpty()) {
                // yep, it's a blank, so just print out a line separator
                outputBuffer.append(ls);
                a.clear();
                return;
            }

            // indent --
            // 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. "else if" is also
            // a special case.
            if (!s.startsWith(" else")
                    && !s.startsWith(" catch")
                    && !s.startsWith(" finally")
                    && !s.startsWith(" ^while")
                    && !s.startsWith(" {")
                    && (!endsWith(outputBuffer, "else") && !endsWith(outputBuffer, "else "))) {
                s = s.trim();
                for (int i = 0; i < level; i++) {
                    s = indent + s;
                }
            }

            // 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();
            }

            // check if the output buffer does NOT end with a new line.  If it
            // doesn't, remove any leading whitespace from this line
            if (!endsWith(outputBuffer, "\u005cn") && !endsWith(outputBuffer, "\u005cr")) {
                s = trimStart(s);
            }

            // check that there aren't extra spaces in the buffer already --
            // this handles the case where the output buffer ends with a space
            // and the new string starts with a space, don't want 2 spaces.
            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 -- this handles the case where the output
            // buffer does not end in a space and the new string does not start
            // with a space, want one space in between.
            if (!s.startsWith(" ")
                    && !endsWith(outputBuffer, " ")
                    && !endsWith(outputBuffer, "\u005cr")
                    && !endsWith(outputBuffer, "\u005cn")
                    && outputBuffer.length() > 0) {
                outputBuffer.append(" ");
            }

            // by the Sun standard, there is no situation where '(' is followed
            // by a space or ')' is preceded with by a space
            s = s.replaceAll("[(][ ]", "(");
            s = s.replaceAll("[ ][)]", ")");

            // there should be no situation where a comma is preceded by a space,
            // although that seems to happen when formatting string arrays.
            s = s.replaceAll("\u005c\u005cs+[,]", ",");

            // finally! add the string to the output buffer
            // check for line length, may need to wrap.  Sun says to avoid lines
            // longer than 80 characters.  This doesn't work well yet, so I've 
            // commented out the wrapping code.  Still need to clean out the
            // wrapping markers.
            //s = s.replaceAll("[]", "");
            outputBuffer.append(s);
            /*
            int wrap_sep_count = countWrapSep(s);
            if (s.length() - wrap_sep_count > 80) {
                String[] lines = wrapLines(s);
                if ( lines != null ) {
                    for (int i = 0; i < lines.length; i++) {
                        outputBuffer.append(lines[i]).append(ls);
                    }
                }
                else {
                    // whack any remaining  characters
                    s = s.replaceAll("[]", "");
                    outputBuffer.append(s);
                }
            }
            else {
                // whack any remaining  characters
                s = s.replaceAll("[]", "");
                outputBuffer.append(s);
            }
            */
            // clear the accumulator for the next line
            a.clear();
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }

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

    static int countWrapSep(String s) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '\u001c') {
                ++count;
            }
        }
        return count;
    }

    // needs work, does a wrap, but not per spec
    static String[] wrapLines(String s) {
        if (s.length() <= 80) {
            return new String[]{s};
        }
        int wc = countWrapSep(s);
        if (wc > 0) {
            int[] break_points = new int[wc];
            int offset = 0;
            for (int i = 0; i < wc; i++) {
                int index = s.indexOf('\u001c', offset);
                break_points[i] = index;
                offset = index + 1;
            }

            int first_break = -1;
            for (int i = 0; i < break_points.length; i++) {
                int possible = break_points[i];
                if (possible > 80) {
                    break;
                }
                first_break = possible;
            }
            if ( first_break == -1 ) {
                first_break = s.length();
            }

            int ws_length = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == ' ')
                    ++ws_length;
                else
                    break;
            }
            String leading_ws = s.substring(0, ws_length);
            String head = s.substring(0, first_break);
            String tail = s.substring(first_break);
            //head = head.replaceAll("[]", "");
            //tail = tail.replaceAll("[]", "");
            return new String[]{head, leading_ws + double_indent + tail};
        }
        return null;
    }

    // StringBuilder doesn't have an "endsWith" method
    static boolean endsWith(StringBuilder 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 writeJavadocComment(String s) {
        String[] lines = s.split("\u005cr\u005cn|\u005cr|\u005cn");

        // indent the first line.  It won't have any leading whitespace, but
        // may have trailing whitespace
        String line = lines[0].trim();
        for (int j = 0; j < level; j++) {
            line = "    " + line;       // 4 spaces
        }
        outputBuffer.append(line).append(ls);

        // handle the remaining lines, put stars in front of them.
        // TODO: this needs work.  Need to preserve whitepsace after
        // the star.
        for (int i = 1; i < lines.length; i++) {
            line = lines[i].trim();

            // apply padding. All javadoc lines start with a *.
            if (line.startsWith("*")) {
                line = " " + line;
            }
            else {
                line = " * " + line;
            }

            // apply indenting. The Sun rule is 4 spaces.
            for (int j = 0; j < level; j++) {
                line = "    " + line;
            }

            outputBuffer.append(line);
            if (i < lines.length - 1) {
                outputBuffer.append(ls);
            }
        }
    }

    // comments of the /* ... */ variety.  This sort of comment is commonly
    // used to "comment out" a block of code, so I don't want to modify the
    // existing indenting within the block.
    static void writeBlockComment(String s) {
        String[] lines = s.split("\u005cr\u005cn|\u005cr|\u005cn");

        // indent the first line.  It won't have any leading whitespace, but
        // may have trailing whitespace
        String line = lines[0].trim();
        for (int j = 0; j < level; j++) {
            line = "    " + line;       // 4 spaces
        }
        outputBuffer.append(line).append(ls);

        // output body of comment without change
        for (int i = 1; i < lines.length - 1; i++) {
            line = lines[i];    // trimStart(lines[i], level * 4);
            outputBuffer.append(line).append(ls);
        }

        // output the last line.  It will probably have leading whitespace, so
        // trim it then indent it the same as the first line.
        line = lines[lines.length - 1].trim();
        for (int j = 0; j < level; j++) {
            line = "    " + line;       // 4 spaces
        }
        outputBuffer.append(line);
    }


    // handle comments like this one
    static void writeEndOfLineComment(String s) {
        String line = s.trim();
        for (int j = 0; j < level; j++) {
            line = "    " + line;       // 4 spaces
        }
        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, long active2)
{
   switch (pos)
   {
      case 0:
         if ((active1 & 0x4000L) != 0L)
            return 15;
         if ((active0 & 0x7fffffffffffe00L) != 0L)
         {
            jjmatchedKind = 67;
            return 39;
         }
         if ((active1 & 0x80008000000000L) != 0L)
            return 60;
         return -1;
      case 1:
         if ((active0 & 0x7ffffff7fcffe00L) != 0L)
         {
            if (jjmatchedPos != 1)
            {
               jjmatchedKind = 67;
               jjmatchedPos = 1;
            }
            return 39;
         }
         if ((active0 & 0x80300000L) != 0L)
            return 39;
         return -1;
      case 2:
         if ((active0 & 0x77fff675feffe00L) != 0L)
         {
            if (jjmatchedPos != 2)
            {
               jjmatchedKind = 67;
               jjmatchedPos = 2;
            }
            return 39;
         }
         if ((active0 & 0x80009820000000L) != 0L)
            return 39;
         return -1;
      case 3:
         if ((active0 & 0x63ffe571f2e9e00L) != 0L)
         {
            if (jjmatchedPos != 3)
            {
               jjmatchedKind = 67;
               jjmatchedPos = 3;
            }
            return 39;
         }
         if ((active0 & 0x140012040c16000L) != 0L)
            return 39;
         return -1;
      case 4:
         if ((active0 & 0x20fbe57012c0600L) != 0L)
         {
            if (jjmatchedPos != 4)
            {
               jjmatchedKind = 67;
               jjmatchedPos = 4;
            }
            return 39;
         }
         if ((active0 & 0x43040001e029800L) != 0L)
            return 39;
         return -1;
      case 5:
         if ((active0 & 0x20d0e15090c0600L) != 0L)
         {
            jjmatchedKind = 67;
            jjmatchedPos = 5;
            return 39;
         }
         if ((active0 & 0x22b04200200000L) != 0L)
            return 39;
         return -1;
      case 6:
         if ((active0 & 0x20d081500040200L) != 0L)
         {
            jjmatchedKind = 67;
            jjmatchedPos = 6;
            return 39;
         }
         if ((active0 & 0x60009080400L) != 0L)
            return 39;
         return -1;
      case 7:
         if ((active0 & 0x201000000040200L) != 0L)
            return 39;
         if ((active0 & 0xc081500000000L) != 0L)
         {
            jjmatchedKind = 67;
            jjmatchedPos = 7;
            return 39;
         }
         return -1;
      case 8:
         if ((active0 & 0x4000500000000L) != 0L)
         {
            jjmatchedKind = 67;
            jjmatchedPos = 8;
            return 39;
         }
         if ((active0 & 0x8081000000000L) != 0L)
            return 39;
         return -1;
      case 9:
         if ((active0 & 0x4000000000000L) != 0L)
         {
            jjmatchedKind = 67;
            jjmatchedPos = 9;
            return 39;
         }
         if ((active0 & 0x500000000L) != 0L)
            return 39;
         return -1;
      case 10:
         if ((active0 & 0x4000000000000L) != 0L)
         {
            if (jjmatchedPos != 10)
            {
               jjmatchedKind = 67;
               jjmatchedPos = 10;
            }
            return 39;
         }
         return -1;
      case 11:
         if ((active0 & 0x4000000000000L) != 0L)
            return 39;
         return -1;
      default :
         return -1;
   }
}
private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
{
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), 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, 0x20000000L, 0x0L);
      case 37:
         jjmatchedKind = 109;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000000L, 0x0L);
      case 38:
         jjmatchedKind = 104;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000100000000L, 0x0L);
      case 40:
         return jjStopAtPos(0, 70);
      case 41:
         return jjStopAtPos(0, 71);
      case 42:
         jjmatchedKind = 102;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L, 0x0L);
      case 43:
         jjmatchedKind = 100;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x10000400000000L, 0x0L);
      case 44:
         return jjStopAtPos(0, 77);
      case 45:
         jjmatchedKind = 101;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x20000800000000L, 0x0L);
      case 46:
         return jjStartNfaWithStates_0(0, 78, 15);
      case 47:
         jjmatchedKind = 103;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L, 0x0L);
      case 58:
         return jjStopAtPos(0, 87);
      case 59:
         return jjStopAtPos(0, 76);
      case 60:
         jjmatchedKind = 82;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000400002000000L, 0x0L);
      case 61:
         jjmatchedKind = 79;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000L, 0x0L);
      case 62:
         jjmatchedKind = 80;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x5000008000000L, 0x5L);
      case 63:
         return jjStopAtPos(0, 86);
      case 64:
         return jjMoveStringLiteralDfa1_0(0x0L, 0x8a0a8a02940a0000L, 0xaL);
      case 91:
         return jjStopAtPos(0, 74);
      case 93:
         return jjStopAtPos(0, 75);
      case 94:
         jjmatchedKind = 108;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L, 0x0L);
      case 97:
         return jjMoveStringLiteralDfa1_0(0x200L, 0x0L, 0x0L);
      case 98:
         return jjMoveStringLiteralDfa1_0(0x2c00L, 0x0L, 0x0L);
      case 99:
         return jjMoveStringLiteralDfa1_0(0x7d000L, 0x0L, 0x0L);
      case 100:
         return jjMoveStringLiteralDfa1_0(0x380000L, 0x0L, 0x0L);
      case 101:
         return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L, 0x0L);
      case 102:
         return jjMoveStringLiteralDfa1_0(0x3e000000L, 0x0L, 0x0L);
      case 103:
         return jjMoveStringLiteralDfa1_0(0x40000000L, 0x0L, 0x0L);
      case 105:
         return jjMoveStringLiteralDfa1_0(0x1f80000000L, 0x0L, 0x0L);
      case 108:
         return jjMoveStringLiteralDfa1_0(0x2000000000L, 0x0L, 0x0L);
      case 110:
         return jjMoveStringLiteralDfa1_0(0x1c000000000L, 0x0L, 0x0L);
      case 112:
         return jjMoveStringLiteralDfa1_0(0x1e0000000000L, 0x0L, 0x0L);
      case 114:
         return jjMoveStringLiteralDfa1_0(0x200000000000L, 0x0L, 0x0L);
      case 115:
         return jjMoveStringLiteralDfa1_0(0x7c00000000000L, 0x0L, 0x0L);
      case 116:
         return jjMoveStringLiteralDfa1_0(0xf8000000000000L, 0x0L, 0x0L);
      case 118:
         return jjMoveStringLiteralDfa1_0(0x300000000000000L, 0x0L, 0x0L);
      case 119:
         return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x0L, 0x0L);
      case 123:
         return jjStopAtPos(0, 72);
      case 124:
         jjmatchedKind = 106;
         return jjMoveStringLiteralDfa1_0(0x0L, 0x400000040000000L, 0x0L);
      case 125:
         return jjStopAtPos(0, 73);
      case 126:
         return jjStopAtPos(0, 85);
      default :
         return jjMoveNfa_0(10, 0);
   }
}
private int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2)
{
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(0, active0, active1, active2);
      return 1;
   }
   switch(curChar)
   {
      case 38:
         if ((active1 & 0x100000000L) != 0L)
            return jjStopAtPos(1, 96);
         break;
      case 43:
         if ((active1 & 0x400000000L) != 0L)
            return jjStopAtPos(1, 98);
         break;
      case 45:
         if ((active1 & 0x800000000L) != 0L)
            return jjStopAtPos(1, 99);
         break;
      case 60:
         if ((active1 & 0x400000000000L) != 0L)
         {
            jjmatchedKind = 110;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000000000000L, active2, 0L);
      case 61:
         if ((active1 & 0x1000000L) != 0L)
            return jjStopAtPos(1, 88);
         else if ((active1 & 0x2000000L) != 0L)
            return jjStopAtPos(1, 89);
         else if ((active1 & 0x8000000L) != 0L)
            return jjStopAtPos(1, 91);
         else if ((active1 & 0x20000000L) != 0L)
            return jjStopAtPos(1, 93);
         else if ((active1 & 0x10000000000000L) != 0L)
            return jjStopAtPos(1, 116);
         else if ((active1 & 0x20000000000000L) != 0L)
            return jjStopAtPos(1, 117);
         else if ((active1 & 0x40000000000000L) != 0L)
            return jjStopAtPos(1, 118);
         else if ((active1 & 0x80000000000000L) != 0L)
            return jjStopAtPos(1, 119);
         else if ((active1 & 0x100000000000000L) != 0L)
            return jjStopAtPos(1, 120);
         else if ((active1 & 0x400000000000000L) != 0L)
            return jjStopAtPos(1, 122);
         else if ((active1 & 0x1000000000000000L) != 0L)
            return jjStopAtPos(1, 124);
         else if ((active1 & 0x2000000000000000L) != 0L)
            return jjStopAtPos(1, 125);
         break;
      case 62:
         if ((active1 & 0x1000000000000L) != 0L)
         {
            jjmatchedKind = 112;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000000000L, active2, 0x5L);
      case 97:
         return jjMoveStringLiteralDfa2_0(active0, 0x2400200c000L, active1, 0x200000200000000L, active2, 0L);
      case 98:
         return jjMoveStringLiteralDfa2_0(active0, 0x200L, active1, 0xa0000000000L, active2, 0L);
      case 101:
         return jjMoveStringLiteralDfa2_0(active0, 0x208000080000L, active1, 0L, active2, 0L);
      case 102:
         if ((active0 & 0x80000000L) != 0L)
            return jjStartNfaWithStates_0(1, 31, 39);
         break;
      case 103:
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10020000L, active2, 0L);
      case 104:
         return jjMoveStringLiteralDfa2_0(active0, 0x430400000010000L, active1, 0L, active2, 0L);
      case 105:
         return jjMoveStringLiteralDfa2_0(active0, 0xc000000L, active1, 0L, active2, 0L);
      case 108:
         return jjMoveStringLiteralDfa2_0(active0, 0x10401000L, active1, 0x8000800004080000L, active2, 0L);
      case 109:
         return jjMoveStringLiteralDfa2_0(active0, 0x300000000L, active1, 0L, active2, 0L);
      case 110:
         return jjMoveStringLiteralDfa2_0(active0, 0x1c00800000L, active1, 0L, active2, 0L);
      case 111:
         if ((active0 & 0x100000L) != 0L)
         {
            jjmatchedKind = 20;
            jjmatchedPos = 1;
         }
         return jjMoveStringLiteralDfa2_0(active0, 0x300002060260400L, active1, 0x800000080000000L, active2, 0L);
      case 114:
         return jjMoveStringLiteralDfa2_0(active0, 0xc80c0000000800L, active1, 0xa000000000000L, active2, 0xaL);
      case 116:
         return jjMoveStringLiteralDfa2_0(active0, 0x1800000000000L, active1, 0L, active2, 0L);
      case 117:
         return jjMoveStringLiteralDfa2_0(active0, 0x110000000000L, active1, 0L, active2, 0L);
      case 119:
         return jjMoveStringLiteralDfa2_0(active0, 0x2000000000000L, active1, 0L, active2, 0L);
      case 120:
         return jjMoveStringLiteralDfa2_0(active0, 0x1000000L, active1, 0L, active2, 0L);
      case 121:
         return jjMoveStringLiteralDfa2_0(active0, 0x4000000002000L, active1, 0L, active2, 0L);
      case 124:
         if ((active1 & 0x40000000L) != 0L)
            return jjStopAtPos(1, 94);
         break;
      default :
         break;
   }
   return jjStartNfa_0(0, active0, active1, active2);
}
private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(0, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(1, active0, active1, active2);
      return 2;
   }
   switch(curChar)
   {
      case 61:
         if ((active1 & 0x4000000000000000L) != 0L)
            return jjStopAtPos(2, 126);
         else if ((active2 & 0x1L) != 0L)
            return jjStopAtPos(2, 128);
         break;
      case 62:
         if ((active1 & 0x4000000000000L) != 0L)
         {
            jjmatchedKind = 114;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x4L);
      case 97:
         return jjMoveStringLiteralDfa3_0(active0, 0x8800000011000L, active1, 0L, active2, 0L);
      case 98:
         return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L, active2, 0L);
      case 99:
         return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L, active1, 0L, active2, 0L);
      case 101:
         return jjMoveStringLiteralDfa3_0(active0, 0x800L, active1, 0x8000800000000000L, active2, 0L);
      case 102:
         return jjMoveStringLiteralDfa3_0(active0, 0x80000L, active1, 0L, active2, 0L);
      case 105:
         return jjMoveStringLiteralDfa3_0(active0, 0x502040000000000L, active1, 0xa0a0000000000L, active2, 0xaL);
      case 108:
         return jjMoveStringLiteralDfa3_0(active0, 0x200010002000000L, active1, 0L, active2, 0L);
      case 110:
         return jjMoveStringLiteralDfa3_0(active0, 0x400200c060000L, active1, 0x200000200000000L, active2, 0L);
      case 111:
         return jjMoveStringLiteralDfa3_0(active0, 0x480010000400L, active1, 0L, active2, 0L);
      case 112:
         return jjMoveStringLiteralDfa3_0(active0, 0x300000000L, active1, 0L, active2, 0L);
      case 114:
         if ((active0 & 0x20000000L) != 0L)
            return jjStartNfaWithStates_0(2, 29, 39);
         else if ((active1 & 0x80000000L) != 0L)
         {
            jjmatchedKind = 95;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0x31000000000000L, active1, 0x800000000000000L, active2, 0L);
      case 115:
         return jjMoveStringLiteralDfa3_0(active0, 0x400404200L, active1, 0L, active2, 0L);
      case 116:
         if ((active0 & 0x800000000L) != 0L)
         {
            jjmatchedKind = 35;
            jjmatchedPos = 2;
         }
         else if ((active1 & 0x20000L) != 0L)
         {
            jjmatchedKind = 81;
            jjmatchedPos = 2;
         }
         else if ((active1 & 0x80000L) != 0L)
         {
            jjmatchedKind = 83;
            jjmatchedPos = 2;
         }
         return jjMoveStringLiteralDfa3_0(active0, 0x20504100a000L, active1, 0x14000000L, active2, 0L);
      case 117:
         return jjMoveStringLiteralDfa3_0(active0, 0x40000000a00000L, active1, 0L, active2, 0L);
      case 119:
         if ((active0 & 0x8000000000L) != 0L)
            return jjStartNfaWithStates_0(2, 39, 39);
         break;
      case 121:
         if ((active0 & 0x80000000000000L) != 0L)
            return jjStartNfaWithStates_0(2, 55, 39);
         break;
      default :
         break;
   }
   return jjStartNfa_0(1, active0, active1, active2);
}
private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(1, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0, active1, active2);
      return 3;
   }
   switch(curChar)
   {
      case 61:
         if ((active2 & 0x4L) != 0L)
            return jjStopAtPos(3, 130);
         break;
      case 95:
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
      case 97:
         return jjMoveStringLiteralDfa4_0(active0, 0x20000001c080800L, active1, 0L, active2, 0L);
      case 98:
         return jjMoveStringLiteralDfa4_0(active0, 0x200000L, active1, 0L, active2, 0L);
      case 99:
         return jjMoveStringLiteralDfa4_0(active0, 0x4000000008000L, active1, 0L, active2, 0L);
      case 100:
         if ((active0 & 0x100000000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 56, 39);
         else if ((active1 & 0x200000000L) != 0L)
         {
            jjmatchedKind = 97;
            jjmatchedPos = 3;
         }
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200000000000000L, active2, 0L);
      case 101:
         if ((active0 & 0x2000L) != 0L)
            return jjStartNfaWithStates_0(3, 13, 39);
         else if ((active0 & 0x4000L) != 0L)
            return jjStartNfaWithStates_0(3, 14, 39);
         else if ((active0 & 0x400000L) != 0L)
            return jjStartNfaWithStates_0(3, 22, 39);
         else if ((active0 & 0x40000000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 54, 39);
         return jjMoveStringLiteralDfa4_0(active0, 0x1001000000L, active1, 0x14000000L, active2, 0L);
      case 102:
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x8000800000000000L, active2, 0L);
      case 103:
         if ((active0 & 0x2000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 37, 39);
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0xa000000000000L, active2, 0xaL);
      case 105:
         return jjMoveStringLiteralDfa4_0(active0, 0x1004000000000L, active1, 0L, active2, 0L);
      case 107:
         return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L, active2, 0L);
      case 108:
         if ((active0 & 0x10000000000L) != 0L)
            return jjStartNfaWithStates_0(3, 40, 39);
         return jjMoveStringLiteralDfa4_0(active0, 0x400100100000400L, active1, 0L, active2, 0L);
      case 109:
         if ((active0 & 0x800000L) != 0L)
            return jjStartNfaWithStates_0(3, 23, 39);
         break;
      case 110:
         return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
      case 111:
         if ((active0 & 0x40000000L) != 0L)
            return jjStartNfaWithStates_0(3, 30, 39);
         return jjMoveStringLiteralDfa4_0(active0, 0x30000200000000L, active1, 0L, active2, 0L);
      case 114:
         if ((active0 & 0x10000L) != 0L)
            return jjStartNfaWithStates_0(3, 16, 39);
         return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L, active2, 0L);
      case 115:
         return jjMoveStringLiteralDfa4_0(active0, 0x2021000L, active1, 0L, active2, 0L);
      case 116:
         return jjMoveStringLiteralDfa4_0(active0, 0x2880400040200L, active1, 0xa0000000000L, active2, 0L);
      case 117:
         return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L, active2, 0L);
      case 118:
         return jjMoveStringLiteralDfa4_0(active0, 0x40000000000L, active1, 0L, active2, 0L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0, active1, active2);
}
private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(2, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(3, active0, active1, active2);
      return 4;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x200000000000000L, active2, 0L);
      case 97:
         return jjMoveStringLiteralDfa5_0(active0, 0x60400000000L, active1, 0x800000000000000L, active2, 0L);
      case 99:
         return jjMoveStringLiteralDfa5_0(active0, 0x3000000000000L, active1, 0L, active2, 0L);
      case 101:
         if ((active0 & 0x2000000L) != 0L)
            return jjStartNfaWithStates_0(4, 25, 39);
         else if ((active0 & 0x400000000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 58, 39);
         return jjMoveStringLiteralDfa5_0(active0, 0x80100000400L, active1, 0L, active2, 0L);
      case 104:
         if ((active0 & 0x8000L) != 0L)
            return jjStartNfaWithStates_0(4, 15, 39);
         return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000L, active1, 0xa000000000000L, active2, 0xaL);
      case 105:
         return jjMoveStringLiteralDfa5_0(active0, 0x900000040000L, active1, 0L, active2, 0L);
      case 107:
         if ((active0 & 0x800L) != 0L)
            return jjStartNfaWithStates_0(4, 11, 39);
         break;
      case 108:
         if ((active0 & 0x4000000L) != 0L)
         {
            jjmatchedKind = 26;
            jjmatchedPos = 4;
         }
         return jjMoveStringLiteralDfa5_0(active0, 0x8200000L, active1, 0L, active2, 0L);
      case 110:
         return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L, active2, 0L);
      case 113:
         if ((active1 & 0x4000000L) != 0L)
            return jjStopAtPos(4, 90);
         else if ((active1 & 0x10000000L) != 0L)
            return jjStopAtPos(4, 92);
         break;
      case 114:
         return jjMoveStringLiteralDfa5_0(active0, 0x201200000200L, active1, 0L, active2, 0L);
      case 115:
         if ((active0 & 0x1000L) != 0L)
            return jjStartNfaWithStates_0(4, 12, 39);
         return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
      case 116:
         if ((active0 & 0x20000L) != 0L)
            return jjStartNfaWithStates_0(4, 17, 39);
         else if ((active0 & 0x10000000L) != 0L)
            return jjStartNfaWithStates_0(4, 28, 39);
         else if ((active0 & 0x400000000000L) != 0L)
            return jjStartNfaWithStates_0(4, 46, 39);
         return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0x8000800000000000L, active2, 0L);
      case 117:
         return jjMoveStringLiteralDfa5_0(active0, 0x80000L, active1, 0L, active2, 0L);
      case 118:
         return jjMoveStringLiteralDfa5_0(active0, 0x4000000000L, active1, 0L, active2, 0L);
      case 119:
         if ((active0 & 0x10000000000000L) != 0L)
         {
            jjmatchedKind = 52;
            jjmatchedPos = 4;
         }
         return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0xa0000000000L, active2, 0L);
      default :
         break;
   }
   return jjStartNfa_0(3, active0, active1, active2);
}
private int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(3, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(4, active0, active1, active2);
      return 5;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x8000800000000000L, active2, 0L);
      case 97:
         return jjMoveStringLiteralDfa6_0(active0, 0x600L, active1, 0x200000000000000L, active2, 0L);
      case 99:
         if ((active0 & 0x100000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 44, 39);
         else if ((active0 & 0x800000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 47, 39);
         return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L, active1, 0L, active2, 0L);
      case 100:
         return jjMoveStringLiteralDfa6_0(active0, 0x1000000L, active1, 0L, active2, 0L);
      case 101:
         if ((active0 & 0x200000L) != 0L)
            return jjStartNfaWithStates_0(5, 21, 39);
         else if ((active0 & 0x4000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 38, 39);
         break;
      case 102:
         return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L, active1, 0L, active2, 0L);
      case 103:
         return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L, active1, 0L, active2, 0L);
      case 104:
         if ((active0 & 0x2000000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 49, 39);
         break;
      case 105:
         return jjMoveStringLiteralDfa6_0(active0, 0x208000000000000L, active1, 0xa0000000000L, active2, 0L);
      case 108:
         return jjMoveStringLiteralDfa6_0(active0, 0x8080000L, active1, 0L, active2, 0L);
      case 109:
         return jjMoveStringLiteralDfa6_0(active0, 0x100000000L, active1, 0L, active2, 0L);
      case 110:
         if ((active0 & 0x200000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 45, 39);
         return jjMoveStringLiteralDfa6_0(active0, 0x400040000L, active1, 0L, active2, 0L);
      case 114:
         return jjMoveStringLiteralDfa6_0(active0, 0x4000000000000L, active1, 0L, active2, 0L);
      case 115:
         if ((active0 & 0x20000000000000L) != 0L)
            return jjStartNfaWithStates_0(5, 53, 39);
         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
      case 116:
         if ((active0 & 0x200000000L) != 0L)
            return jjStartNfaWithStates_0(5, 33, 39);
         return jjMoveStringLiteralDfa6_0(active0, 0x1040000000000L, active1, 0xa000000000000L, active2, 0xaL);
      default :
         break;
   }
   return jjStartNfa_0(4, active0, active1, active2);
}
private int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(4, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(5, active0, active1, active2);
      return 6;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0xa000000000000L, active2, 0xaL);
      case 97:
         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000L, active1, 0L, active2, 0L);
      case 99:
         return jjMoveStringLiteralDfa7_0(active0, 0x400000200L, active1, 0L, active2, 0L);
      case 101:
         if ((active0 & 0x20000000000L) != 0L)
            return jjStartNfaWithStates_0(6, 41, 39);
         else if ((active0 & 0x40000000000L) != 0L)
            return jjStartNfaWithStates_0(6, 42, 39);
         return jjMoveStringLiteralDfa7_0(active0, 0x8000100000000L, active1, 0L, active2, 0L);
      case 102:
         return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L, active1, 0L, active2, 0L);
      case 108:
         return jjMoveStringLiteralDfa7_0(active0, 0x200000000000000L, active1, 0L, active2, 0L);
      case 110:
         if ((active0 & 0x400L) != 0L)
            return jjStartNfaWithStates_0(6, 10, 39);
         break;
      case 111:
         return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000L, active1, 0L, active2, 0L);
      case 115:
         if ((active0 & 0x1000000L) != 0L)
            return jjStartNfaWithStates_0(6, 24, 39);
         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x8a008a0000000000L, active2, 0L);
      case 116:
         if ((active0 & 0x80000L) != 0L)
            return jjStartNfaWithStates_0(6, 19, 39);
         return jjMoveStringLiteralDfa7_0(active0, 0x80000000000L, active1, 0L, active2, 0L);
      case 117:
         return jjMoveStringLiteralDfa7_0(active0, 0x40000L, active1, 0L, active2, 0L);
      case 121:
         if ((active0 & 0x8000000L) != 0L)
            return jjStartNfaWithStates_0(6, 27, 39);
         break;
      default :
         break;
   }
   return jjStartNfa_0(5, active0, active1, active2);
}
private int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(5, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(6, active0, active1, active2);
      return 7;
   }
   switch(curChar)
   {
      case 99:
         return jjMoveStringLiteralDfa8_0(active0, 0x1000000000L, active1, 0L, active2, 0L);
      case 101:
         if ((active0 & 0x40000L) != 0L)
            return jjStartNfaWithStates_0(7, 18, 39);
         else if ((active0 & 0x200000000000000L) != 0L)
            return jjStartNfaWithStates_0(7, 57, 39);
         return jjMoveStringLiteralDfa8_0(active0, 0x80400000000L, active1, 0xa0000000000L, active2, 0L);
      case 104:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x8000800000000000L, active2, 0L);
      case 105:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
      case 110:
         return jjMoveStringLiteralDfa8_0(active0, 0xc000100000000L, active1, 0L, active2, 0L);
      case 112:
         if ((active0 & 0x1000000000000L) != 0L)
            return jjStartNfaWithStates_0(7, 48, 39);
         break;
      case 115:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x202000000000000L, active2, 0x2L);
      case 116:
         if ((active0 & 0x200L) != 0L)
            return jjStartNfaWithStates_0(7, 9, 39);
         break;
      case 117:
         return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x8000000000000L, active2, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(6, active0, active1, active2);
}
private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(6, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(7, active0, active1, active2);
      return 8;
   }
   switch(curChar)
   {
      case 95:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0xa0000000000L, active2, 0L);
      case 100:
         if ((active0 & 0x80000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 43, 39);
         break;
      case 101:
         if ((active0 & 0x1000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 36, 39);
         break;
      case 103:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x800000000000000L, active2, 0L);
      case 104:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x2000000000000L, active2, 0x2L);
      case 105:
         return jjMoveStringLiteralDfa9_0(active0, 0x4000000000000L, active1, 0x8200800000000000L, active2, 0L);
      case 110:
         return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x8000000000000L, active2, 0x8L);
      case 111:
         return jjMoveStringLiteralDfa9_0(active0, 0x400000000L, active1, 0L, active2, 0L);
      case 116:
         if ((active0 & 0x8000000000000L) != 0L)
            return jjStartNfaWithStates_0(8, 51, 39);
         return jjMoveStringLiteralDfa9_0(active0, 0x100000000L, active1, 0L, active2, 0L);
      default :
         break;
   }
   return jjStartNfa_0(7, active0, active1, active2);
}
private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1, long old2, long active2)
{
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
      return jjStartNfa_0(7, old0, old1, old2);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(8, active0, active1, active2);
      return 9;
   }
   switch(curChar)
   {
      case 97:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x20000000000L, active2, 0L);
      case 102:
         if ((active0 & 0x400000000L) != 0L)
            return jjStartNfaWithStates_0(9, 34, 39);
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000800000000000L, active2, 0L);
      case 103:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x200000000000000L, active2, 0L);
      case 105:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x2000000000000L, active2, 0x2L);
      case 110:
         if ((active1 & 0x800000000000000L) != 0L)
            return jjStopAtPos(9, 123);
         break;
      case 111:
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x80000000000L, active2, 0L);
      case 115:
         if ((active0 & 0x100000000L) != 0L)
            return jjStartNfaWithStates_0(9, 32, 39);
         return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000000000L, active2, 0x8L);
      case 122:
         return jjMoveStringLiteralDfa10_0(active0, 0x4000000000000L, active1, 0L, active2, 0L);
      default :
         break;…