/* Generated By:JavaCC: Do not edit this line. CueryParserTokenManager.java */
package org.trix.cuery.parser;

public class CueryParserTokenManager implements CueryParserConstants {

    private String trimBy(StringBuffer buffer, int left, int right) {
        return buffer.toString().substring(left, buffer.length() - right);
    }

    private String trimUrl(StringBuffer buffer) {
        buffer = new StringBuffer(trimBy(buffer, 4, 1).trim());
        int end = buffer.length() - 1;

        if ((buffer.charAt(0) == '"' && buffer.charAt(end) == '"')
                || (buffer.charAt(0) == '\'' && buffer.charAt(end) == '\'')) {
            return trimBy(buffer, 1, 1);
        } else {
            return buffer.toString();
        }
    }

    public java.io.PrintStream debugStream = System.out;

    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 ((active1 & 0x10000000L) != 0L) {
                jjmatchedKind = 47;
                return 51;
            }
            if ((active0 & 0x3000L) != 0L || (active1 & 0x40000L) != 0L) return 198;
            if ((active0 & 0x80L) != 0L) return 365;
            if ((active1 & 0xc000000L) != 0L) {
                jjmatchedKind = 47;
                return 366;
            }
            if ((active0 & 0x3ffe00000L) != 0L) return 1;
            return -1;
        case 1:
            if ((active0 & 0x3ffe00000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 1;
                return 367;
            }
            if ((active1 & 0x1c000000L) != 0L) {
                jjmatchedKind = 47;
                jjmatchedPos = 1;
                return 366;
            }
            return -1;
        case 2:
            if ((active0 & 0x3ffe00000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 2;
                return 367;
            }
            if ((active1 & 0x1c000000L) != 0L) {
                jjmatchedKind = 47;
                jjmatchedPos = 2;
                return 366;
            }
            return -1;
        case 3:
            if ((active0 & 0x2000000L) != 0L) return 367;
            if ((active1 & 0x4000000L) != 0L) {
                jjmatchedKind = 47;
                jjmatchedPos = 3;
                return 366;
            }
            if ((active0 & 0x3fde00000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 3;
                return 367;
            }
            return -1;
        case 4:
            if ((active0 & 0x80800000L) != 0L) return 367;
            if ((active0 & 0x37d600000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 4;
                return 367;
            }
            if ((active1 & 0x4000000L) != 0L) {
                jjmatchedKind = 47;
                jjmatchedPos = 4;
                return 366;
            }
            return -1;
        case 5:
            if ((active0 & 0x33c600000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 5;
                return 367;
            }
            if ((active0 & 0x41000000L) != 0L) return 367;
            if ((active1 & 0x4000000L) != 0L) {
                jjmatchedKind = 47;
                jjmatchedPos = 5;
                return 366;
            }
            return -1;
        case 6:
            if ((active0 & 0x20200000L) != 0L) return 367;
            if ((active0 & 0x31c400000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 6;
                return 367;
            }
            if ((active1 & 0x4000000L) != 0L) {
                jjmatchedKind = 47;
                jjmatchedPos = 6;
                return 366;
            }
            return -1;
        case 7:
            if ((active0 & 0x318000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 7;
                return 367;
            }
            if ((active0 & 0x4400000L) != 0L) return 367;
            return -1;
        case 8:
            if ((active0 & 0x318000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 8;
                return 367;
            }
            return -1;
        case 9:
            if ((active0 & 0x10000000L) != 0L) return 367;
            if ((active0 & 0x308000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 9;
                return 367;
            }
            return -1;
        case 10:
            if ((active0 & 0x108000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 10;
                return 367;
            }
            if ((active0 & 0x200000000L) != 0L) return 367;
            return -1;
        case 11:
            if ((active0 & 0x108000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 11;
                return 367;
            }
            return -1;
        case 12:
            if ((active0 & 0x108000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 12;
                return 367;
            }
            return -1;
        case 13:
            if ((active0 & 0x8000000L) != 0L) return 367;
            if ((active0 & 0x100000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 13;
                return 367;
            }
            return -1;
        case 14:
            if ((active0 & 0x100000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 14;
                return 367;
            }
            return -1;
        case 15:
            if ((active0 & 0x100000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 15;
                return 367;
            }
            return -1;
        case 16:
            if ((active0 & 0x100000000L) != 0L) {
                jjmatchedKind = 34;
                jjmatchedPos = 16;
                return 367;
            }
            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 final int jjStopAtPos(int pos, int kind) {
        jjmatchedKind = kind;
        jjmatchedPos = pos;
        return pos + 1;
    }

    private final 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);
    }

    private final int jjMoveStringLiteralDfa0_0() {
        switch (curChar) {
        case 36:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x800000L);
        case 40:
            return jjStopAtPos(0, 18);
        case 41:
            return jjStopAtPos(0, 19);
        case 42:
            jjmatchedKind = 10;
            return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000L);
        case 43:
            return jjStartNfaWithStates_0(0, 12, 198);
        case 44:
            return jjStopAtPos(0, 6);
        case 45:
            jjmatchedKind = 13;
            return jjMoveStringLiteralDfa1_0(0x0L, 0x40000L);
        case 46:
            return jjStartNfaWithStates_0(0, 7, 365);
        case 47:
            jjmatchedKind = 11;
            return jjMoveStringLiteralDfa1_0(0x2L, 0x0L);
        case 58:
            return jjStopAtPos(0, 9);
        case 59:
            return jjStopAtPos(0, 8);
        case 60:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x20000L);
        case 61:
            return jjStopAtPos(0, 14);
        case 62:
            return jjStopAtPos(0, 15);
        case 64:
            return jjMoveStringLiteralDfa1_0(0x3ffe00000L, 0x0L);
        case 91:
            return jjStopAtPos(0, 16);
        case 93:
            return jjStopAtPos(0, 17);
        case 94:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x400000L);
        case 73:
        case 105:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L);
        case 78:
        case 110:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
        case 82:
        case 114:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L);
        case 123:
            return jjStopAtPos(0, 4);
        case 124:
            return jjMoveStringLiteralDfa1_0(0x0L, 0x200000L);
        case 125:
            return jjStopAtPos(0, 5);
        case 126:
            jjmatchedKind = 20;
            return jjMoveStringLiteralDfa1_0(0x0L, 0x100000L);
        default:
            return jjMoveNfa_0(0, 0);
        }
    }

    private final 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 33:
            return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x20000L);
        case 42:
            if ((active0 & 0x2L) != 0L) return jjStopAtPos(1, 1);
            break;
        case 45:
            return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000L);
        case 61:
            if ((active1 & 0x100000L) != 0L)
                return jjStopAtPos(1, 84);
            else if ((active1 & 0x200000L) != 0L)
                return jjStopAtPos(1, 85);
            else if ((active1 & 0x400000L) != 0L)
                return jjStopAtPos(1, 86);
            else if ((active1 & 0x800000L) != 0L)
                return jjStopAtPos(1, 87);
            else if ((active1 & 0x1000000L) != 0L) return jjStopAtPos(1, 88);
            break;
        case 66:
        case 98:
            return jjMoveStringLiteralDfa2_0(active0, 0x200000L, active1, 0L);
        case 67:
        case 99:
            return jjMoveStringLiteralDfa2_0(active0, 0xc400000L, active1, 0L);
        case 70:
        case 102:
            return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
        case 71:
        case 103:
            return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000L);
        case 73:
        case 105:
            return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
        case 76:
        case 108:
            return jjMoveStringLiteralDfa2_0(active0, 0x800000L, active1, 0L);
        case 77:
        case 109:
            return jjMoveStringLiteralDfa2_0(active0, 0x40000000L, active1, 0L);
        case 78:
        case 110:
            return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000L);
        case 79:
        case 111:
            return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x10000000L);
        case 80:
        case 112:
            return jjMoveStringLiteralDfa2_0(active0, 0x380000000L, active1, 0L);
        case 82:
        case 114:
            return jjMoveStringLiteralDfa2_0(active0, 0x1000000L, active1, 0L);
        case 84:
        case 116:
            return jjMoveStringLiteralDfa2_0(active0, 0x2000000L, active1, 0L);
        default:
            break;
        }
        return jjStartNfa_0(0, active0, active1);
    }

    private final 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 45:
            return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000L);
        case 62:
            if ((active1 & 0x40000L) != 0L) return jjStopAtPos(2, 82);
            break;
        case 65:
        case 97:
            return jjMoveStringLiteralDfa3_0(active0, 0x80000000L, active1, 0L);
        case 66:
        case 98:
            return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000L);
        case 69:
        case 101:
            return jjMoveStringLiteralDfa3_0(active0, 0x40800000L, active1, 0L);
        case 72:
        case 104:
            return jjMoveStringLiteralDfa3_0(active0, 0x104000000L, active1, 0x4000000L);
        case 73:
        case 105:
            return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L);
        case 77:
        case 109:
            return jjMoveStringLiteralDfa3_0(active0, 0x20000000L, active1, 0L);
        case 79:
        case 111:
            return jjMoveStringLiteralDfa3_0(active0, 0x1a600000L, active1, 0L);
        case 82:
        case 114:
            return jjMoveStringLiteralDfa3_0(active0, 0x200000000L, active1, 0L);
        case 84:
        case 116:
            return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x10000000L);
        default:
            break;
        }
        return jjStartNfa_0(1, active0, active1);
    }

    private final 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 40:
            if ((active1 & 0x8000000L) != 0L)
                return jjStopAtPos(3, 91);
            else if ((active1 & 0x10000000L) != 0L) return jjStopAtPos(3, 92);
            break;
        case 45:
            if ((active1 & 0x20000L) != 0L) return jjStopAtPos(3, 81);
            break;
        case 65:
        case 97:
            return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L);
        case 68:
        case 100:
            return jjMoveStringLiteralDfa4_0(active0, 0x40000000L, active1, 0L);
        case 69:
        case 101:
            return jjMoveStringLiteralDfa4_0(active0, 0x200000000L, active1, 0x4000000L);
        case 70:
        case 102:
            return jjMoveStringLiteralDfa4_0(active0, 0x800000L, active1, 0L);
        case 71:
        case 103:
            return jjMoveStringLiteralDfa4_0(active0, 0x81000000L, active1, 0L);
        case 76:
        case 108:
            return jjMoveStringLiteralDfa4_0(active0, 0x8000000L, active1, 0L);
        case 78:
        case 110:
            return jjMoveStringLiteralDfa4_0(active0, 0x10000000L, active1, 0L);
        case 79:
        case 111:
            return jjMoveStringLiteralDfa4_0(active0, 0x100000000L, active1, 0L);
        case 80:
        case 112:
            if ((active0 & 0x2000000L) != 0L) return jjStartNfaWithStates_0(3, 25, 367);
            return jjMoveStringLiteralDfa4_0(active0, 0x20000000L, active1, 0L);
        case 84:
        case 116:
            return jjMoveStringLiteralDfa4_0(active0, 0x200000L, active1, 0L);
        case 85:
        case 117:
            return jjMoveStringLiteralDfa4_0(active0, 0x400000L, active1, 0L);
        default:
            break;
        }
        return jjStartNfa_0(2, active0, active1);
    }

    private final 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, active1);
            return 4;
        }
        switch (curChar) {
        case 69:
        case 101:
            if ((active0 & 0x80000000L) != 0L) return jjStartNfaWithStates_0(4, 31, 367);
            break;
        case 70:
        case 102:
            return jjMoveStringLiteralDfa5_0(active0, 0x200000000L, active1, 0L);
        case 72:
        case 104:
            return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L);
        case 73:
        case 105:
            return jjMoveStringLiteralDfa5_0(active0, 0x40000000L, active1, 0L);
        case 78:
        case 110:
            return jjMoveStringLiteralDfa5_0(active0, 0x100400000L, active1, 0L);
        case 79:
        case 111:
            return jjMoveStringLiteralDfa5_0(active0, 0x28000000L, active1, 0L);
        case 82:
        case 114:
            return jjMoveStringLiteralDfa5_0(active0, 0x4000000L, active1, 0x4000000L);
        case 84:
        case 116:
            if ((active0 & 0x800000L) != 0L) return jjStartNfaWithStates_0(4, 23, 367);
            return jjMoveStringLiteralDfa5_0(active0, 0x10200000L, active1, 0L);
        default:
            break;
        }
        return jjStartNfa_0(3, active0, active1);
    }

    private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) return jjStartNfa_0(3, old0, old1);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(4, active0, active1);
            return 5;
        }
        switch (curChar) {
        case 45:
            return jjMoveStringLiteralDfa6_0(active0, 0x10000000L, active1, 0L);
        case 65:
        case 97:
            if ((active0 & 0x40000000L) != 0L) return jjStartNfaWithStates_0(5, 30, 367);
            break;
        case 69:
        case 101:
            return jjMoveStringLiteralDfa6_0(active0, 0x300000000L, active1, 0L);
        case 73:
        case 105:
            return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x4000000L);
        case 79:
        case 111:
            return jjMoveStringLiteralDfa6_0(active0, 0x200000L, active1, 0L);
        case 82:
        case 114:
            return jjMoveStringLiteralDfa6_0(active0, 0x28000000L, active1, 0L);
        case 83:
        case 115:
            return jjMoveStringLiteralDfa6_0(active0, 0x4000000L, active1, 0L);
        case 84:
        case 116:
            if ((active0 & 0x1000000L) != 0L) return jjStartNfaWithStates_0(5, 24, 367);
            return jjMoveStringLiteralDfa6_0(active0, 0x400000L, active1, 0L);
        default:
            break;
        }
        return jjStartNfa_0(4, active0, active1);
    }

    private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) return jjStartNfa_0(4, old0, old1);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(5, active0, active1);
            return 6;
        }
        switch (curChar) {
        case 45:
            return jjMoveStringLiteralDfa7_0(active0, 0x8000000L, active1, 0L);
        case 69:
        case 101:
            return jjMoveStringLiteralDfa7_0(active0, 0x4400000L, active1, 0L);
        case 70:
        case 102:
            return jjMoveStringLiteralDfa7_0(active0, 0x10000000L, active1, 0L);
        case 77:
        case 109:
            if ((active0 & 0x200000L) != 0L) return jjStartNfaWithStates_0(6, 21, 367);
            break;
        case 82:
        case 114:
            return jjMoveStringLiteralDfa7_0(active0, 0x200000000L, active1, 0L);
        case 84:
        case 116:
            if ((active0 & 0x20000000L) != 0L)
                return jjStartNfaWithStates_0(6, 29, 367);
            else if ((active1 & 0x4000000L) != 0L) return jjStartNfaWithStates_0(6, 47, 366);
            return jjMoveStringLiteralDfa7_0(active0, 0x100000000L, active1, 0L);
        default:
            break;
        }
        return jjStartNfa_0(5, active0, active1);
    }

    private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) return jjStartNfa_0(5, old0, old1);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(6, active0, 0L);
            return 7;
        }
        switch (curChar) {
        case 65:
        case 97:
            return jjMoveStringLiteralDfa8_0(active0, 0x10000000L);
        case 69:
        case 101:
            return jjMoveStringLiteralDfa8_0(active0, 0x200000000L);
        case 73:
        case 105:
            return jjMoveStringLiteralDfa8_0(active0, 0x100000000L);
        case 80:
        case 112:
            return jjMoveStringLiteralDfa8_0(active0, 0x8000000L);
        case 82:
        case 114:
            if ((active0 & 0x400000L) != 0L) return jjStartNfaWithStates_0(7, 22, 367);
            break;
        case 84:
        case 116:
            if ((active0 & 0x4000000L) != 0L) return jjStartNfaWithStates_0(7, 26, 367);
            break;
        default:
            break;
        }
        return jjStartNfa_0(6, active0, 0L);
    }

    private final 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 67:
        case 99:
            return jjMoveStringLiteralDfa9_0(active0, 0x110000000L);
        case 78:
        case 110:
            return jjMoveStringLiteralDfa9_0(active0, 0x200000000L);
        case 82:
        case 114:
            return jjMoveStringLiteralDfa9_0(active0, 0x8000000L);
        default:
            break;
        }
        return jjStartNfa_0(7, active0, 0L);
    }

    private final 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 45:
            return jjMoveStringLiteralDfa10_0(active0, 0x100000000L);
        case 67:
        case 99:
            return jjMoveStringLiteralDfa10_0(active0, 0x200000000L);
        case 69:
        case 101:
            if ((active0 & 0x10000000L) != 0L) return jjStartNfaWithStates_0(9, 28, 367);
            break;
        case 79:
        case 111:
            return jjMoveStringLiteralDfa10_0(active0, 0x8000000L);
        default:
            break;
        }
        return jjStartNfa_0(8, active0, 0L);
    }

    private final 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 65:
        case 97:
            return jjMoveStringLiteralDfa11_0(active0, 0x100000000L);
        case 69:
        case 101:
            if ((active0 & 0x200000000L) != 0L) return jjStartNfaWithStates_0(10, 33, 367);
            break;
        case 70:
        case 102:
            return jjMoveStringLiteralDfa11_0(active0, 0x8000000L);
        default:
            break;
        }
        return jjStartNfa_0(9, active0, 0L);
    }

    private final 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 73:
        case 105:
            return jjMoveStringLiteralDfa12_0(active0, 0x8000000L);
        case 76:
        case 108:
            return jjMoveStringLiteralDfa12_0(active0, 0x100000000L);
        default:
            break;
        }
        return jjStartNfa_0(10, active0, 0L);
    }

    private final int jjMoveStringLiteralDfa12_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) return jjStartNfa_0(10, old0, 0L);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(11, active0, 0L);
            return 12;
        }
        switch (curChar) {
        case 76:
        case 108:
            return jjMoveStringLiteralDfa13_0(active0, 0x8000000L);
        case 80:
        case 112:
            return jjMoveStringLiteralDfa13_0(active0, 0x100000000L);
        default:
            break;
        }
        return jjStartNfa_0(11, active0, 0L);
    }

    private final int jjMoveStringLiteralDfa13_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) return jjStartNfa_0(11, old0, 0L);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(12, active0, 0L);
            return 13;
        }
        switch (curChar) {
        case 69:
        case 101:
            if ((active0 & 0x8000000L) != 0L) return jjStartNfaWithStates_0(13, 27, 367);
            break;
        case 72:
        case 104:
            return jjMoveStringLiteralDfa14_0(active0, 0x100000000L);
        default:
            break;
        }
        return jjStartNfa_0(12, active0, 0L);
    }

    private final int jjMoveStringLiteralDfa14_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) return jjStartNfa_0(12, old0, 0L);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(13, active0, 0L);
            return 14;
        }
        switch (curChar) {
        case 65:
        case 97:
            return jjMoveStringLiteralDfa15_0(active0, 0x100000000L);
        default:
            break;
        }
        return jjStartNfa_0(13, active0, 0L);
    }

    private final int jjMoveStringLiteralDfa15_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) return jjStartNfa_0(13, old0, 0L);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(14, active0, 0L);
            return 15;
        }
        switch (curChar) {
        case 66:
        case 98:
            return jjMoveStringLiteralDfa16_0(active0, 0x100000000L);
        default:
            break;
        }
        return jjStartNfa_0(14, active0, 0L);
    }

    private final int jjMoveStringLiteralDfa16_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) return jjStartNfa_0(14, old0, 0L);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(15, active0, 0L);
            return 16;
        }
        switch (curChar) {
        case 69:
        case 101:
            return jjMoveStringLiteralDfa17_0(active0, 0x100000000L);
        default:
            break;
        }
        return jjStartNfa_0(15, active0, 0L);
    }

    private final int jjMoveStringLiteralDfa17_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) return jjStartNfa_0(15, old0, 0L);
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(16, active0, 0L);
            return 17;
        }
        switch (curChar) {
        case 84:
        case 116:
            if ((active0 & 0x100000000L) != 0L) return jjStartNfaWithStates_0(17, 32, 367);
            break;
        default:
            break;
        }
        return jjStartNfa_0(16, active0, 0L);
    }

    private final void jjCheckNAdd(int state) {
        if (jjrounds[state] != jjround) {
            jjstateSet[jjnewStateCnt++] = state;
            jjrounds[state] = jjround;
        }
    }

    private final void jjAddStates(int start, int end) {
        do {
            jjstateSet[jjnewStateCnt++] = jjnextStates[start];
        } while (start++ != end);
    }

    private final void jjCheckNAddTwoStates(int state1, int state2) {
        jjCheckNAdd(state1);
        jjCheckNAdd(state2);
    }

    private final void jjCheckNAddStates(int start, int end) {
        do {
            jjCheckNAdd(jjnextStates[start]);
        } while (start++ != end);
    }

    private final void jjCheckNAddStates(int start) {
        jjCheckNAdd(jjnextStates[start]);
        jjCheckNAdd(jjnextStates[start + 1]);
    }

    static final long[] jjbitVec0 = {0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL};

    static final long[] jjbitVec2 = {0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL};

    private final int jjMoveNfa_0(int startState, int curPos) {
        int[] nextStates;
        int startsAt = 0;
        jjnewStateCnt = 365;
        int i = 1;
        jjstateSet[0] = startState;
        int j, kind = 0x7fffffff;
        for (;;) {
            if (++jjround == 0x7fffffff) ReInitRounds();
            if (curChar < 64) {
                long l = 1L << curChar;
                MatchLoop: do {
                    switch (jjstateSet[--i]) {
                    case 366:
                        if ((0x3ff200000000000L & l) != 0L)
                            jjCheckNAddStates(0, 2);
                        else if (curChar == 40) {
                            if (kind > 93) kind = 93;
                        }
                        if ((0x3ff200000000000L & l) != 0L) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddTwoStates(76, 77);
                        }
                        break;
                    case 198:
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(257, 258);
                        else if (curChar == 46) jjCheckNAdd(179);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(256, 180);
                        else if (curChar == 46) jjCheckNAdd(160);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(254, 255);
                        else if (curChar == 46) jjCheckNAdd(153);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddStates(3, 5);
                        else if (curChar == 46) jjCheckNAdd(151);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(251, 252);
                        else if (curChar == 46) jjCheckNAdd(148);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(250, 154);
                        else if (curChar == 46) jjCheckNAdd(146);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(248, 249);
                        else if (curChar == 46) jjCheckNAdd(143);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(247, 152);
                        else if (curChar == 46) jjCheckNAdd(140);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(245, 246);
                        else if (curChar == 46) jjCheckNAdd(137);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(244, 150);
                        else if (curChar == 46) jjCheckNAdd(134);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(242, 243);
                        else if (curChar == 46) jjCheckNAdd(131);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(241, 147);
                        else if (curChar == 46) jjCheckNAdd(128);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(239, 240);
                        else if (curChar == 46) jjCheckNAdd(125);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(238, 145);
                        else if (curChar == 46) jjCheckNAdd(121);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(236, 237);
                        else if (curChar == 46) jjCheckNAdd(118);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(235, 142);
                        else if (curChar == 46) jjCheckNAdd(115);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(233, 234);
                        else if (curChar == 46) jjCheckNAdd(112);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(232, 139);
                        else if (curChar == 46) jjCheckNAdd(108);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(230, 231);
                        else if (curChar == 46) jjCheckNAdd(103);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(229, 136);
                        else if (curChar == 46) jjCheckNAdd(99);
                        if ((0x3ff000000000000L & l) != 0L)
                            jjCheckNAddTwoStates(227, 228);
                        else if (curChar == 46) jjCheckNAdd(98);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(226, 133);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(224, 225);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(223, 130);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(221, 222);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(220, 127);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(218, 219);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(217, 124);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(215, 216);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(214, 120);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(212, 213);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(211, 117);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(209, 210);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(208, 114);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(206, 207);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(205, 111);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(203, 204);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(202, 107);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(200, 201);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(199, 102);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAdd(50);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(196, 197);
                        if ((0x3ff000000000000L & l) != 0L) {
                            if (kind > 48) kind = 48;
                            jjCheckNAdd(195);
                        }
                        break;
                    case 367:
                    case 2:
                        if ((0x3ff200000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 0:
                        if ((0x3ff000000000000L & l) != 0L) {
                            if (kind > 48) kind = 48;
                            jjCheckNAddStates(6, 90);
                        } else if ((0x100003600L & l) != 0L) {
                            if (kind > 35) kind = 35;
                            jjCheckNAdd(19);
                        } else if ((0x280000000000L & l) != 0L)
                            jjCheckNAddStates(91, 155);
                        else if (curChar == 46)
                            jjCheckNAddStates(156, 176);
                        else if (curChar == 33)
                            jjCheckNAddTwoStates(65, 74);
                        else if (curChar == 35)
                            jjCheckNAddTwoStates(54, 55);
                        else if (curChar == 39)
                            jjCheckNAddStates(177, 180);
                        else if (curChar == 34) jjCheckNAddStates(181, 184);
                        break;
                    case 365:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(179, 180);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(185, 187);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(153, 154);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(151, 152);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(148, 150);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(146, 147);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(143, 145);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(140, 142);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(137, 139);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(134, 136);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(131, 133);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(128, 130);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(125, 127);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(121, 124);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(118, 120);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(115, 117);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(112, 114);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(108, 111);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(103, 107);
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(99, 102);
                        if ((0x3ff000000000000L & l) != 0L) {
                            if (kind > 48) kind = 48;
                            jjCheckNAdd(98);
                        }
                        break;
                    case 51:
                        if ((0x3ff200000000000L & l) != 0L)
                            jjCheckNAddStates(0, 2);
                        else if (curChar == 40) {
                            if (kind > 93) kind = 93;
                        }
                        if ((0x3ff200000000000L & l) != 0L) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddTwoStates(76, 77);
                        }
                        if ((0x280000000000L & l) != 0L) jjCheckNAdd(52);
                        break;
                    case 4:
                        if ((0xffffffff00000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 5:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(188, 191);
                        break;
                    case 6:
                        if ((0x100003600L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 7:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(192, 198);
                        break;
                    case 8:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(199, 201);
                        break;
                    case 9:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(202, 205);
                        break;
                    case 10:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(206, 210);
                        break;
                    case 11:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(211, 216);
                        break;
                    case 13:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(217, 220);
                        break;
                    case 14:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(221, 227);
                        break;
                    case 15:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(228, 230);
                        break;
                    case 16:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(231, 234);
                        break;
                    case 17:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(235, 239);
                        break;
                    case 18:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(240, 245);
                        break;
                    case 19:
                        if ((0x100003600L & l) == 0L) break;
                        if (kind > 35) kind = 35;
                        jjCheckNAdd(19);
                        break;
                    case 20:
                        if (curChar == 34) jjCheckNAddStates(181, 184);
                        break;
                    case 21:
                        if ((0xfffffffb00000200L & l) != 0L) jjCheckNAddStates(181, 184);
                        break;
                    case 22:
                        if (curChar == 34 && kind > 46) kind = 46;
                        break;
                    case 24:
                        if (curChar == 10) jjCheckNAddStates(181, 184);
                        break;
                    case 26:
                        if ((0xffffffff00000000L & l) != 0L) jjCheckNAddStates(181, 184);
                        break;
                    case 27:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(246, 251);
                        break;
                    case 28:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(181, 184);
                        break;
                    case 29:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(252, 260);
                        break;
                    case 30:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(261, 265);
                        break;
                    case 31:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(266, 271);
                        break;
                    case 32:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(272, 278);
                        break;
                    case 33:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(279, 286);
                        break;
                    case 34:
                        if (curChar == 13) jjstateSet[jjnewStateCnt++] = 24;
                        break;
                    case 35:
                        if (curChar == 39) jjCheckNAddStates(177, 180);
                        break;
                    case 36:
                        if ((0xffffff7f00000200L & l) != 0L) jjCheckNAddStates(177, 180);
                        break;
                    case 37:
                        if (curChar == 39 && kind > 46) kind = 46;
                        break;
                    case 39:
                        if (curChar == 10) jjCheckNAddStates(177, 180);
                        break;
                    case 41:
                        if ((0xffffffff00000000L & l) != 0L) jjCheckNAddStates(177, 180);
                        break;
                    case 42:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(287, 292);
                        break;
                    case 43:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(177, 180);
                        break;
                    case 44:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(293, 301);
                        break;
                    case 45:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(302, 306);
                        break;
                    case 46:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(307, 312);
                        break;
                    case 47:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(313, 319);
                        break;
                    case 48:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(320, 327);
                        break;
                    case 49:
                        if (curChar == 13) jjstateSet[jjnewStateCnt++] = 39;
                        break;
                    case 52:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 49) kind = 49;
                        jjCheckNAdd(52);
                        break;
                    case 53:
                        if (curChar == 35) jjCheckNAddTwoStates(54, 55);
                        break;
                    case 54:
                        if ((0x3ff200000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 56:
                        if ((0xffffffff00000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 57:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(328, 331);
                        break;
                    case 58:
                        if ((0x100003600L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 59:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(332, 338);
                        break;
                    case 60:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(339, 341);
                        break;
                    case 61:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(342, 345);
                        break;
                    case 62:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(346, 350);
                        break;
                    case 63:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(351, 356);
                        break;
                    case 64:
                        if (curChar == 33) jjCheckNAddTwoStates(65, 74);
                        break;
                    case 65:
                        if ((0x100003600L & l) != 0L) jjCheckNAddTwoStates(65, 74);
                        break;
                    case 76:
                        if ((0x3ff200000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 78:
                        if ((0xffffffff00000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 79:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(357, 360);
                        break;
                    case 80:
                        if ((0x100003600L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 81:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(361, 367);
                        break;
                    case 82:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(368, 370);
                        break;
                    case 83:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(371, 374);
                        break;
                    case 84:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(375, 379);
                        break;
                    case 85:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(380, 385);
                        break;
                    case 86:
                        if ((0x3ff200000000000L & l) != 0L) jjCheckNAddStates(0, 2);
                        break;
                    case 87:
                        if (curChar == 40 && kind > 93) kind = 93;
                        break;
                    case 89:
                        if ((0xffffffff00000000L & l) != 0L) jjCheckNAddStates(0, 2);
                        break;
                    case 90:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(386, 390);
                        break;
                    case 91:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(0, 2);
                        break;
                    case 92:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(391, 398);
                        break;
                    case 93:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(399, 402);
                        break;
                    case 94:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(403, 407);
                        break;
                    case 95:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(408, 413);
                        break;
                    case 96:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(414, 420);
                        break;
                    case 97:
                        if (curChar == 46) jjCheckNAddStates(156, 176);
                        break;
                    case 98:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 48) kind = 48;
                        jjCheckNAdd(98);
                        break;
                    case 99:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(99, 102);
                        break;
                    case 103:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(103, 107);
                        break;
                    case 108:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(108, 111);
                        break;
                    case 112:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(112, 114);
                        break;
                    case 115:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(115, 117);
                        break;
                    case 118:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(118, 120);
                        break;
                    case 121:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(121, 124);
                        break;
                    case 125:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(125, 127);
                        break;
                    case 128:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(128, 130);
                        break;
                    case 131:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(131, 133);
                        break;
                    case 134:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(134, 136);
                        break;
                    case 137:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(137, 139);
                        break;
                    case 140:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(140, 142);
                        break;
                    case 143:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(143, 145);
                        break;
                    case 146:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(146, 147);
                        break;
                    case 147:
                        if (curChar == 37 && kind > 75) kind = 75;
                        break;
                    case 148:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(148, 150);
                        break;
                    case 151:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(151, 152);
                        break;
                    case 153:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(153, 154);
                        break;
                    case 160:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(185, 187);
                        break;
                    case 162:
                        if ((0x3ff200000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 164:
                        if ((0xffffffff00000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 165:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(421, 424);
                        break;
                    case 166:
                        if ((0x100003600L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 167:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(425, 431);
                        break;
                    case 168:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(432, 434);
                        break;
                    case 169:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(435, 438);
                        break;
                    case 170:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(439, 443);
                        break;
                    case 171:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(444, 449);
                        break;
                    case 173:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(450, 453);
                        break;
                    case 174:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(454, 460);
                        break;
                    case 175:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(461, 463);
                        break;
                    case 176:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(464, 467);
                        break;
                    case 177:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(468, 472);
                        break;
                    case 178:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(473, 478);
                        break;
                    case 179:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(179, 180);
                        break;
                    case 180:
                        if (curChar == 47) jjCheckNAddStates(479, 481);
                        break;
                    case 181:
                        if (curChar == 46) jjCheckNAdd(182);
                        break;
                    case 182:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(182, 183);
                        break;
                    case 183:
                        if (curChar == 47) jjCheckNAddStates(482, 484);
                        break;
                    case 184:
                        if (curChar == 46) jjCheckNAdd(185);
                        break;
                    case 185:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 80) kind = 80;
                        jjCheckNAdd(185);
                        break;
                    case 186:
                        if ((0x280000000000L & l) != 0L) jjCheckNAddStates(485, 487);
                        break;
                    case 187:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 80) kind = 80;
                        jjCheckNAdd(187);
                        break;
                    case 188:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(188, 184);
                        break;
                    case 189:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 80) kind = 80;
                        jjCheckNAddStates(485, 487);
                        break;
                    case 190:
                        if ((0x280000000000L & l) != 0L) jjCheckNAddStates(488, 490);
                        break;
                    case 191:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(191, 183);
                        break;
                    case 192:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(192, 181);
                        break;
                    case 193:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(491, 494);
                        break;
                    case 194:
                        if ((0x280000000000L & l) != 0L) jjCheckNAddStates(91, 155);
                        break;
                    case 195:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 48) kind = 48;
                        jjCheckNAdd(195);
                        break;
                    case 196:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(196, 197);
                        break;
                    case 197:
                        if (curChar == 46) jjCheckNAdd(98);
                        break;
                    case 199:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(199, 102);
                        break;
                    case 200:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(200, 201);
                        break;
                    case 201:
                        if (curChar == 46) jjCheckNAdd(99);
                        break;
                    case 202:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(202, 107);
                        break;
                    case 203:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(203, 204);
                        break;
                    case 204:
                        if (curChar == 46) jjCheckNAdd(103);
                        break;
                    case 205:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(205, 111);
                        break;
                    case 206:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(206, 207);
                        break;
                    case 207:
                        if (curChar == 46) jjCheckNAdd(108);
                        break;
                    case 208:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(208, 114);
                        break;
                    case 209:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(209, 210);
                        break;
                    case 210:
                        if (curChar == 46) jjCheckNAdd(112);
                        break;
                    case 211:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(211, 117);
                        break;
                    case 212:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(212, 213);
                        break;
                    case 213:
                        if (curChar == 46) jjCheckNAdd(115);
                        break;
                    case 214:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(214, 120);
                        break;
                    case 215:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(215, 216);
                        break;
                    case 216:
                        if (curChar == 46) jjCheckNAdd(118);
                        break;
                    case 217:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(217, 124);
                        break;
                    case 218:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(218, 219);
                        break;
                    case 219:
                        if (curChar == 46) jjCheckNAdd(121);
                        break;
                    case 220:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(220, 127);
                        break;
                    case 221:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(221, 222);
                        break;
                    case 222:
                        if (curChar == 46) jjCheckNAdd(125);
                        break;
                    case 223:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(223, 130);
                        break;
                    case 224:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(224, 225);
                        break;
                    case 225:
                        if (curChar == 46) jjCheckNAdd(128);
                        break;
                    case 226:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(226, 133);
                        break;
                    case 227:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(227, 228);
                        break;
                    case 228:
                        if (curChar == 46) jjCheckNAdd(131);
                        break;
                    case 229:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(229, 136);
                        break;
                    case 230:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(230, 231);
                        break;
                    case 231:
                        if (curChar == 46) jjCheckNAdd(134);
                        break;
                    case 232:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(232, 139);
                        break;
                    case 233:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(233, 234);
                        break;
                    case 234:
                        if (curChar == 46) jjCheckNAdd(137);
                        break;
                    case 235:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(235, 142);
                        break;
                    case 236:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(236, 237);
                        break;
                    case 237:
                        if (curChar == 46) jjCheckNAdd(140);
                        break;
                    case 238:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(238, 145);
                        break;
                    case 239:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(239, 240);
                        break;
                    case 240:
                        if (curChar == 46) jjCheckNAdd(143);
                        break;
                    case 241:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(241, 147);
                        break;
                    case 242:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(242, 243);
                        break;
                    case 243:
                        if (curChar == 46) jjCheckNAdd(146);
                        break;
                    case 244:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(244, 150);
                        break;
                    case 245:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(245, 246);
                        break;
                    case 246:
                        if (curChar == 46) jjCheckNAdd(148);
                        break;
                    case 247:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(247, 152);
                        break;
                    case 248:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(248, 249);
                        break;
                    case 249:
                        if (curChar == 46) jjCheckNAdd(151);
                        break;
                    case 250:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(250, 154);
                        break;
                    case 251:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(251, 252);
                        break;
                    case 252:
                        if (curChar == 46) jjCheckNAdd(153);
                        break;
                    case 253:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(3, 5);
                        break;
                    case 254:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(254, 255);
                        break;
                    case 255:
                        if (curChar == 46) jjCheckNAdd(160);
                        break;
                    case 256:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(256, 180);
                        break;
                    case 257:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(257, 258);
                        break;
                    case 258:
                        if (curChar == 46) jjCheckNAdd(179);
                        break;
                    case 259:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 48) kind = 48;
                        jjCheckNAddStates(6, 90);
                        break;
                    case 261:
                        if (curChar == 40) jjCheckNAddStates(495, 500);
                        break;
                    case 262:
                        if ((0xfffffc7a00000000L & l) != 0L) jjCheckNAddStates(501, 504);
                        break;
                    case 263:
                        if ((0x100003600L & l) != 0L) jjCheckNAddTwoStates(263, 264);
                        break;
                    case 264:
                        if (curChar == 41 && kind > 50) kind = 50;
                        break;
                    case 266:
                        if ((0xffffffff00000000L & l) != 0L) jjCheckNAddStates(501, 504);
                        break;
                    case 267:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(505, 509);
                        break;
                    case 268:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(501, 504);
                        break;
                    case 269:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(510, 517);
                        break;
                    case 270:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(518, 521);
                        break;
                    case 271:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(522, 526);
                        break;
                    case 272:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(527, 532);
                        break;
                    case 273:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(533, 539);
                        break;
                    case 274:
                        if (curChar == 39) jjCheckNAddStates(540, 543);
                        break;
                    case 275:
                        if ((0xffffff7f00000200L & l) != 0L) jjCheckNAddStates(540, 543);
                        break;
                    case 276:
                        if (curChar == 39) jjCheckNAddTwoStates(263, 264);
                        break;
                    case 278:
                        if (curChar == 10) jjCheckNAddStates(540, 543);
                        break;
                    case 280:
                        if ((0xffffffff00000000L & l) != 0L) jjCheckNAddStates(540, 543);
                        break;
                    case 281:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(544, 549);
                        break;
                    case 282:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(540, 543);
                        break;
                    case 283:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(550, 558);
                        break;
                    case 284:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(559, 563);
                        break;
                    case 285:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(564, 569);
                        break;
                    case 286:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(570, 576);
                        break;
                    case 287:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(577, 584);
                        break;
                    case 288:
                        if (curChar == 13) jjstateSet[jjnewStateCnt++] = 278;
                        break;
                    case 289:
                        if (curChar == 34) jjCheckNAddStates(585, 588);
                        break;
                    case 290:
                        if ((0xfffffffb00000200L & l) != 0L) jjCheckNAddStates(585, 588);
                        break;
                    case 291:
                        if (curChar == 34) jjCheckNAddTwoStates(263, 264);
                        break;
                    case 293:
                        if (curChar == 10) jjCheckNAddStates(585, 588);
                        break;
                    case 295:
                        if ((0xffffffff00000000L & l) != 0L) jjCheckNAddStates(585, 588);
                        break;
                    case 296:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(589, 594);
                        break;
                    case 297:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(585, 588);
                        break;
                    case 298:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(595, 603);
                        break;
                    case 299:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(604, 608);
                        break;
                    case 300:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(609, 614);
                        break;
                    case 301:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(615, 621);
                        break;
                    case 302:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(622, 629);
                        break;
                    case 303:
                        if (curChar == 13) jjstateSet[jjnewStateCnt++] = 293;
                        break;
                    case 304:
                        if ((0x100003600L & l) != 0L) jjCheckNAddStates(630, 636);
                        break;
                    case 307:
                        if (curChar == 43) jjAddStates(637, 638);
                        break;
                    case 308:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 309;
                        break;
                    case 309:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(639, 642);
                        break;
                    case 310:
                        if (curChar == 63 && kind > 51) kind = 51;
                        break;
                    case 311:
                    case 326:
                    case 330:
                    case 333:
                    case 336:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAdd(310);
                        break;
                    case 312:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddTwoStates(310, 311);
                        break;
                    case 313:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(643, 645);
                        break;
                    case 314:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjAddStates(646, 651);
                        break;
                    case 315:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 316;
                        break;
                    case 316:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 317;
                        break;
                    case 317:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAdd(318);
                        break;
                    case 318:
                        if ((0x3ff000000000000L & l) != 0L && kind > 51) kind = 51;
                        break;
                    case 319:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 320;
                        break;
                    case 320:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 321;
                        break;
                    case 321:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 322;
                        break;
                    case 322:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAdd(310);
                        break;
                    case 323:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 324;
                        break;
                    case 324:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 325;
                        break;
                    case 325:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 326;
                        break;
                    case 327:
                        if ((0x3ff000000000000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 328;
                        break;
                    case 328:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 329;
                        break;
                    case 329:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddTwoStates(310, 330);
                        break;
                    case 331:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 332;
                        break;
                    case 332:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(652, 654);
                        break;
                    case 334:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddTwoStates(310, 333);
                        break;
                    case 335:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(655, 658);
                        break;
                    case 337:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddTwoStates(310, 336);
                        break;
                    case 338:
                        if (curChar != 63) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(659, 661);
                        break;
                    case 339:
                        if (curChar == 43) jjstateSet[jjnewStateCnt++] = 340;
                        break;
                    case 340:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(341, 347);
                        break;
                    case 341:
                        if (curChar == 45) jjstateSet[jjnewStateCnt++] = 342;
                        break;
                    case 342:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 343;
                        break;
                    case 343:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(662, 665);
                        break;
                    case 344:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAdd(318);
                        break;
                    case 345:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddTwoStates(318, 344);
                        break;
                    case 346:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(666, 668);
                        break;
                    case 347:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(669, 673);
                        break;
                    case 348:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAdd(341);
                        break;
                    case 349:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddTwoStates(348, 341);
                        break;
                    case 350:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(674, 676);
                        break;
                    case 351:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(677, 680);
                        break;
                    case 353:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(681, 684);
                        break;
                    case 354:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(685, 691);
                        break;
                    case 355:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(692, 694);
                        break;
                    case 356:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(695, 698);
                        break;
                    case 357:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(699, 703);
                        break;
                    case 358:
                        if ((0x3ff000000000000L & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(704, 709);
                        break;
                    case 359:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(710, 714);
                        break;
                    case 360:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(715, 722);
                        break;
                    case 361:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(723, 726);
                        break;
                    case 362:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(727, 731);
                        break;
                    case 363:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(732, 737);
                        break;
                    case 364:
                        if ((0x3ff000000000000L & l) != 0L) jjCheckNAddStates(738, 744);
                        break;
                    default:
                        break;
                    }
                } while (i != startsAt);
            } else if (curChar < 128) {
                long l = 1L << (curChar & 077);
                MatchLoop: do {
                    switch (jjstateSet[--i]) {
                    case 366:
                        if ((0x7fffffe87fffffeL & l) != 0L)
                            jjCheckNAddStates(0, 2);
                        else if (curChar == 92) jjCheckNAddTwoStates(78, 79);
                        if ((0x7fffffe87fffffeL & l) != 0L) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddTwoStates(76, 77);
                        } else if (curChar == 92) jjCheckNAddTwoStates(89, 90);
                        break;
                    case 198:
                    case 50:
                        if ((0x400000004000L & l) == 0L) break;
                        if (kind > 49) kind = 49;
                        jjstateSet[jjnewStateCnt++] = 51;
                        break;
                    case 367:
                        if ((0x7fffffe87fffffeL & l) != 0L) {
                            if (kind > 34) kind = 34;
                            jjCheckNAddTwoStates(2, 3);
                        } else if (curChar == 92) jjCheckNAddTwoStates(4, 5);
                        break;
                    case 0:
                        if ((0x7fffffe87fffffeL & l) != 0L) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddStates(745, 749);
                        } else if (curChar == 92)
                            jjCheckNAddStates(750, 753);
                        else if (curChar == 64) jjAddStates(754, 755);
                        if ((0x20000000200000L & l) != 0L)
                            jjAddStates(756, 758);
                        else if ((0x400000004000L & l) != 0L) {
                            if (kind > 49) kind = 49;
                            jjstateSet[jjnewStateCnt++] = 51;
                        }
                        break;
                    case 1:
                        if ((0x7fffffe87fffffeL & l) != 0L) {
                            if (kind > 34) kind = 34;
                            jjCheckNAddTwoStates(2, 3);
                        } else if (curChar == 92) jjCheckNAddTwoStates(4, 13);
                        break;
                    case 51:
                        if ((0x7fffffe87fffffeL & l) != 0L)
                            jjCheckNAddStates(0, 2);
                        else if (curChar == 92) jjCheckNAddTwoStates(78, 79);
                        if ((0x7fffffe87fffffeL & l) != 0L) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddTwoStates(76, 77);
                        } else if (curChar == 92) jjCheckNAddTwoStates(89, 90);
                        break;
                    case 2:
                        if ((0x7fffffe87fffffeL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 3:
                        if (curChar == 92) jjCheckNAddTwoStates(4, 5);
                        break;
                    case 4:
                        if ((0x7fffffffffffffffL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 5:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(188, 191);
                        break;
                    case 7:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(192, 198);
                        break;
                    case 8:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(199, 201);
                        break;
                    case 9:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(202, 205);
                        break;
                    case 10:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(206, 210);
                        break;
                    case 11:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(211, 216);
                        break;
                    case 12:
                        if (curChar == 92) jjCheckNAddTwoStates(4, 13);
                        break;
                    case 13:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(217, 220);
                        break;
                    case 14:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(221, 227);
                        break;
                    case 15:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(228, 230);
                        break;
                    case 16:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(231, 234);
                        break;
                    case 17:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(235, 239);
                        break;
                    case 18:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddStates(240, 245);
                        break;
                    case 21:
                    case 26:
                        if ((0x7fffffffffffffffL & l) != 0L) jjCheckNAddStates(181, 184);
                        break;
                    case 23:
                        if (curChar == 92) jjAddStates(759, 760);
                        break;
                    case 25:
                        if (curChar == 92) jjAddStates(761, 762);
                        break;
                    case 27:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(246, 251);
                        break;
                    case 29:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(252, 260);
                        break;
                    case 30:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(261, 265);
                        break;
                    case 31:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(266, 271);
                        break;
                    case 32:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(272, 278);
                        break;
                    case 33:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(279, 286);
                        break;
                    case 36:
                    case 41:
                        if ((0x7fffffffffffffffL & l) != 0L) jjCheckNAddStates(177, 180);
                        break;
                    case 38:
                        if (curChar == 92) jjAddStates(763, 764);
                        break;
                    case 40:
                        if (curChar == 92) jjAddStates(765, 766);
                        break;
                    case 42:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(287, 292);
                        break;
                    case 44:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(293, 301);
                        break;
                    case 45:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(302, 306);
                        break;
                    case 46:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(307, 312);
                        break;
                    case 47:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(313, 319);
                        break;
                    case 48:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(320, 327);
                        break;
                    case 54:
                        if ((0x7fffffe87fffffeL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 55:
                        if (curChar == 92) jjAddStates(767, 768);
                        break;
                    case 56:
                        if ((0x7fffffffffffffffL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 57:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(328, 331);
                        break;
                    case 59:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(332, 338);
                        break;
                    case 60:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(339, 341);
                        break;
                    case 61:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(342, 345);
                        break;
                    case 62:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(346, 350);
                        break;
                    case 63:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddStates(351, 356);
                        break;
                    case 66:
                        if ((0x10000000100000L & l) != 0L && kind > 89) kind = 89;
                        break;
                    case 67:
                        if ((0x400000004000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 66;
                        break;
                    case 68:
                        if ((0x200000002L & l) != 0L) jjstateSet[jjnewStateCnt++] = 67;
                        break;
                    case 69:
                        if ((0x10000000100000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 68;
                        break;
                    case 70:
                        if ((0x4000000040000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 69;
                        break;
                    case 71:
                        if ((0x800000008000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 70;
                        break;
                    case 72:
                        if ((0x1000000010000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 71;
                        break;
                    case 73:
                        if ((0x200000002000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 72;
                        break;
                    case 74:
                        if ((0x20000000200L & l) != 0L) jjstateSet[jjnewStateCnt++] = 73;
                        break;
                    case 75:
                        if ((0x7fffffe87fffffeL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(745, 749);
                        break;
                    case 76:
                        if ((0x7fffffe87fffffeL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 77:
                        if (curChar == 92) jjCheckNAddTwoStates(78, 79);
                        break;
                    case 78:
                        if ((0x7fffffffffffffffL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 79:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(357, 360);
                        break;
                    case 81:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(361, 367);
                        break;
                    case 82:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(368, 370);
                        break;
                    case 83:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(371, 374);
                        break;
                    case 84:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(375, 379);
                        break;
                    case 85:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(380, 385);
                        break;
                    case 86:
                        if ((0x7fffffe87fffffeL & l) != 0L) jjCheckNAddStates(0, 2);
                        break;
                    case 88:
                        if (curChar == 92) jjCheckNAddTwoStates(89, 90);
                        break;
                    case 89:
                        if ((0x7fffffffffffffffL & l) != 0L) jjCheckNAddStates(0, 2);
                        break;
                    case 90:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(386, 390);
                        break;
                    case 92:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(391, 398);
                        break;
                    case 93:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(399, 402);
                        break;
                    case 94:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(403, 407);
                        break;
                    case 95:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(408, 413);
                        break;
                    case 96:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(414, 420);
                        break;
                    case 100:
                        if ((0x8000000080L & l) != 0L && kind > 61) kind = 61;
                        break;
                    case 101:
                        if ((0x2000000020L & l) != 0L) jjstateSet[jjnewStateCnt++] = 100;
                        break;
                    case 102:
                        if ((0x1000000010L & l) != 0L) jjstateSet[jjnewStateCnt++] = 101;
                        break;
                    case 104:
                        if ((0x1000000010L & l) != 0L && kind > 62) kind = 62;
                        break;
                    case 105:
                        if ((0x200000002L & l) != 0L) jjstateSet[jjnewStateCnt++] = 104;
                        break;
                    case 106:
                        if ((0x4000000040000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 105;
                        break;
                    case 107:
                        if ((0x8000000080L & l) != 0L) jjstateSet[jjnewStateCnt++] = 106;
                        break;
                    case 109:
                        if ((0x1000000010L & l) != 0L && kind > 63) kind = 63;
                        break;
                    case 110:
                        if ((0x200000002L & l) != 0L) jjstateSet[jjnewStateCnt++] = 109;
                        break;
                    case 111:
                        if ((0x4000000040000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 110;
                        break;
                    case 113:
                        if ((0x200000002000L & l) != 0L && kind > 64) kind = 64;
                        break;
                    case 114:
                        if ((0x2000000020L & l) != 0L) jjstateSet[jjnewStateCnt++] = 113;
                        break;
                    case 116:
                        if ((0x100000001000000L & l) != 0L && kind > 65) kind = 65;
                        break;
                    case 117:
                        if ((0x2000000020L & l) != 0L) jjstateSet[jjnewStateCnt++] = 116;
                        break;
                    case 119:
                        if ((0x400000004000000L & l) != 0L && kind > 66) kind = 66;
                        break;
                    case 120:
                        if ((0x10000000100L & l) != 0L) jjstateSet[jjnewStateCnt++] = 119;
                        break;
                    case 122:
                        if ((0x400000004000000L & l) != 0L && kind > 67) kind = 67;
                        break;
                    case 123:
                        if ((0x10000000100L & l) != 0L) jjstateSet[jjnewStateCnt++] = 122;
                        break;
                    case 124:
                        if ((0x80000000800L & l) != 0L) jjstateSet[jjnewStateCnt++] = 123;
                        break;
                    case 126:
                        if ((0x200000002000L & l) != 0L && kind > 68) kind = 68;
                        break;
                    case 127:
                        if ((0x800000008L & l) != 0L) jjstateSet[jjnewStateCnt++] = 126;
                        break;
                    case 129:
                        if ((0x400000004000L & l) != 0L && kind > 69) kind = 69;
                        break;
                    case 130:
                        if ((0x20000000200L & l) != 0L) jjstateSet[jjnewStateCnt++] = 129;
                        break;
                    case 132:
                        if ((0x1000000010L & l) != 0L && kind > 70) kind = 70;
                        break;
                    case 133:
                        if ((0x8000000080L & l) != 0L) jjstateSet[jjnewStateCnt++] = 132;
                        break;
                    case 135:
                        if ((0x200000002000L & l) != 0L && kind > 71) kind = 71;
                        break;
                    case 136:
                        if ((0x200000002000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 135;
                        break;
                    case 138:
                        if ((0x800000008L & l) != 0L && kind > 72) kind = 72;
                        break;
                    case 139:
                        if ((0x1000000010000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 138;
                        break;
                    case 141:
                        if ((0x10000000100000L & l) != 0L && kind > 73) kind = 73;
                        break;
                    case 142:
                        if ((0x1000000010000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 141;
                        break;
                    case 144:
                        if ((0x100000001000000L & l) != 0L && kind > 74) kind = 74;
                        break;
                    case 145:
                        if ((0x1000000010000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 144;
                        break;
                    case 149:
                        if ((0x8000000080000L & l) != 0L && kind > 76) kind = 76;
                        break;
                    case 150:
                        if ((0x200000002000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 149;
                        break;
                    case 152:
                        if ((0x8000000080000L & l) != 0L && kind > 77) kind = 77;
                        break;
                    case 154:
                        if ((0x1000000010L & l) != 0L) jjAddStates(769, 770);
                        break;
                    case 155:
                        if ((0x20000000200L & l) != 0L && kind > 78) kind = 78;
                        break;
                    case 156:
                        if ((0x1000000010000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 155;
                        break;
                    case 157:
                        if ((0x200000002000L & l) != 0L && kind > 78) kind = 78;
                        break;
                    case 158:
                        if ((0x800000008L & l) != 0L) jjstateSet[jjnewStateCnt++] = 157;
                        break;
                    case 159:
                        if ((0x1000000010000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 158;
                        break;
                    case 161:
                    case 162:
                        if ((0x7fffffe87fffffeL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 163:
                        if (curChar == 92) jjCheckNAddTwoStates(164, 165);
                        break;
                    case 164:
                        if ((0x7fffffffffffffffL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 165:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(421, 424);
                        break;
                    case 167:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(425, 431);
                        break;
                    case 168:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(432, 434);
                        break;
                    case 169:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(435, 438);
                        break;
                    case 170:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(439, 443);
                        break;
                    case 171:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(444, 449);
                        break;
                    case 172:
                        if (curChar == 92) jjCheckNAddTwoStates(164, 173);
                        break;
                    case 173:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(450, 453);
                        break;
                    case 174:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(454, 460);
                        break;
                    case 175:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(461, 463);
                        break;
                    case 176:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(464, 467);
                        break;
                    case 177:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(468, 472);
                        break;
                    case 178:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddStates(473, 478);
                        break;
                    case 260:
                        if ((0x20000000200000L & l) != 0L) jjAddStates(756, 758);
                        break;
                    case 262:
                    case 266:
                        if ((0x7fffffffffffffffL & l) != 0L) jjCheckNAddStates(501, 504);
                        break;
                    case 265:
                        if (curChar == 92) jjAddStates(771, 772);
                        break;
                    case 267:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(505, 509);
                        break;
                    case 269:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(510, 517);
                        break;
                    case 270:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(518, 521);
                        break;
                    case 271:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(522, 526);
                        break;
                    case 272:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(527, 532);
                        break;
                    case 273:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(533, 539);
                        break;
                    case 275:
                    case 280:
                        if ((0x7fffffffffffffffL & l) != 0L) jjCheckNAddStates(540, 543);
                        break;
                    case 277:
                        if (curChar == 92) jjAddStates(773, 774);
                        break;
                    case 279:
                        if (curChar == 92) jjAddStates(775, 776);
                        break;
                    case 281:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(544, 549);
                        break;
                    case 283:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(550, 558);
                        break;
                    case 284:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(559, 563);
                        break;
                    case 285:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(564, 569);
                        break;
                    case 286:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(570, 576);
                        break;
                    case 287:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(577, 584);
                        break;
                    case 290:
                    case 295:
                        if ((0x7fffffffffffffffL & l) != 0L) jjCheckNAddStates(585, 588);
                        break;
                    case 292:
                        if (curChar == 92) jjAddStates(777, 778);
                        break;
                    case 294:
                        if (curChar == 92) jjAddStates(779, 780);
                        break;
                    case 296:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(589, 594);
                        break;
                    case 298:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(595, 603);
                        break;
                    case 299:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(604, 608);
                        break;
                    case 300:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(609, 614);
                        break;
                    case 301:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(615, 621);
                        break;
                    case 302:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(622, 629);
                        break;
                    case 305:
                        if ((0x100000001000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 261;
                        break;
                    case 306:
                        if ((0x4000000040000L & l) != 0L) jjstateSet[jjnewStateCnt++] = 305;
                        break;
                    case 314:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjAddStates(646, 651);
                        break;
                    case 315:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 316;
                        break;
                    case 316:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 317;
                        break;
                    case 317:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAdd(318);
                        break;
                    case 318:
                        if ((0x7e0000007eL & l) != 0L && kind > 51) kind = 51;
                        break;
                    case 319:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 320;
                        break;
                    case 320:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 321;
                        break;
                    case 321:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 322;
                        break;
                    case 322:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 310;
                        break;
                    case 323:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 324;
                        break;
                    case 324:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 325;
                        break;
                    case 325:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 326;
                        break;
                    case 327:
                        if ((0x7e0000007eL & l) != 0L) jjstateSet[jjnewStateCnt++] = 328;
                        break;
                    case 328:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 329;
                        break;
                    case 331:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 332;
                        break;
                    case 340:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddTwoStates(341, 347);
                        break;
                    case 342:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjstateSet[jjnewStateCnt++] = 343;
                        break;
                    case 343:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(662, 665);
                        break;
                    case 344:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAdd(318);
                        break;
                    case 345:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddTwoStates(318, 344);
                        break;
                    case 346:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 51) kind = 51;
                        jjCheckNAddStates(666, 668);
                        break;
                    case 347:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(669, 673);
                        break;
                    case 348:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAdd(341);
                        break;
                    case 349:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddTwoStates(348, 341);
                        break;
                    case 350:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(674, 676);
                        break;
                    case 351:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(677, 680);
                        break;
                    case 352:
                        if (curChar == 92) jjCheckNAddStates(750, 753);
                        break;
                    case 353:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(681, 684);
                        break;
                    case 354:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(685, 691);
                        break;
                    case 355:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(692, 694);
                        break;
                    case 356:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(695, 698);
                        break;
                    case 357:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(699, 703);
                        break;
                    case 358:
                        if ((0x7e0000007eL & l) == 0L) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(704, 709);
                        break;
                    case 359:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(710, 714);
                        break;
                    case 360:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(715, 722);
                        break;
                    case 361:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(723, 726);
                        break;
                    case 362:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(727, 731);
                        break;
                    case 363:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(732, 737);
                        break;
                    case 364:
                        if ((0x7e0000007eL & l) != 0L) jjCheckNAddStates(738, 744);
                        break;
                    default:
                        break;
                    }
                } while (i != startsAt);
            } else {
                int hiByte = (int) (curChar >> 8);
                int i1 = hiByte >> 6;
                long l1 = 1L << (hiByte & 077);
                int i2 = (curChar & 0xff) >> 6;
                long l2 = 1L << (curChar & 077);
                MatchLoop: do {
                    switch (jjstateSet[--i]) {
                    case 366:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddTwoStates(76, 77);
                        }
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(0, 2);
                        break;
                    case 367:
                    case 2:
                        if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 0:
                        if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddStates(745, 749);
                        break;
                    case 1:
                        if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 51:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                            if (kind > 47) kind = 47;
                            jjCheckNAddTwoStates(76, 77);
                        }
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(0, 2);
                        break;
                    case 4:
                        if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 34) kind = 34;
                        jjCheckNAddTwoStates(2, 3);
                        break;
                    case 21:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(181, 184);
                        break;
                    case 26:
                        if (jjCanMove_1(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(181, 184);
                        break;
                    case 36:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(177, 180);
                        break;
                    case 41:
                        if (jjCanMove_1(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(177, 180);
                        break;
                    case 54:
                        if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 56:
                        if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 83) kind = 83;
                        jjCheckNAddTwoStates(54, 55);
                        break;
                    case 76:
                        if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 78:
                        if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 47) kind = 47;
                        jjCheckNAddTwoStates(76, 77);
                        break;
                    case 86:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(0, 2);
                        break;
                    case 89:
                        if (jjCanMove_1(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(0, 2);
                        break;
                    case 161:
                    case 162:
                        if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 164:
                        if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) break;
                        if (kind > 79) kind = 79;
                        jjCheckNAddTwoStates(162, 163);
                        break;
                    case 262:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(501, 504);
                        break;
                    case 266:
                        if (jjCanMove_1(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(501, 504);
                        break;
                    case 275:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(540, 543);
                        break;
                    case 280:
                        if (jjCanMove_1(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(540, 543);
                        break;
                    case 290:
                        if (jjCanMove_0(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(585, 588);
                        break;
                    case 295:
                        if (jjCanMove_1(hiByte, i1, i2, l1, l2)) jjCheckNAddStates(585, 588);
                        break;
                    default:
                        break;
                    }
                } while (i != startsAt);
            }
            if (kind != 0x7fffffff) {
                jjmatchedKind = kind;
                jjmatchedPos = curPos;
                kind = 0x7fffffff;
            }
            ++curPos;
            if ((i = jjnewStateCnt) == (startsAt = 365 - (jjnewStateCnt = startsAt))) return curPos;
            try {
                curChar = input_stream.readChar();
            } catch (java.io.IOException e) {
                return curPos;
            }
        }
    }

    private final int jjMoveStringLiteralDfa0_1() {
        switch (curChar) {
        case 42:
            return jjMoveStringLiteralDfa1_1(0x4L);
        default:
            return 1;
        }
    }

    private final int jjMoveStringLiteralDfa1_1(long active0) {
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            return 1;
        }
        switch (curChar) {
        case 47:
            if ((active0 & 0x4L) != 0L) return jjStopAtPos(1, 2);
            break;
        default:
            return 2;
        }
        return 2;
    }

    static final int[] jjnextStates = {86, 87, 88, 253, 161, 172, 195, 196, 197, 50, 199, 200, 201, 102, 202, 203, 204,
            107, 205, 206, 207, 111, 208, 209, 210, 114, 211, 212, 213, 117, 214, 215, 216, 120, 217, 218, 219, 124,
            220, 221, 222, 127, 223, 224, 225, 130, 226, 227, 228, 133, 229, 230, 231, 136, 232, 233, 234, 139, 235,
            236, 237, 142, 238, 239, 240, 145, 241, 242, 243, 147, 244, 245, 246, 150, 247, 248, 249, 152, 250, 251,
            252, 253, 254, 255, 161, 256, 257, 258, 180, 172, 154, 195, 196, 197, 198, 50, 199, 200, 201, 202, 203,
            204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
            225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
            246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 98, 99, 103, 108, 112, 115, 118, 121, 125,
            128, 131, 134, 137, 140, 143, 146, 148, 151, 153, 160, 179, 36, 37, 38, 40, 21, 22, 23, 25, 160, 161, 172,
            2, 6, 3, 7, 2, 8, 6, 3, 9, 10, 11, 2, 6, 3, 2, 8, 6, 3, 2, 8, 6, 3, 9, 2, 8, 6, 3, 9, 10, 6, 2, 3, 14, 15,
            6, 2, 3, 16, 17, 18, 6, 2, 3, 15, 6, 2, 3, 15, 6, 2, 3, 16, 15, 6, 2, 3, 16, 17, 21, 28, 22, 23, 25, 29,
            21, 30, 28, 22, 23, 25, 31, 32, 33, 21, 28, 22, 23, 25, 21, 30, 28, 22, 23, 25, 21, 30, 28, 22, 23, 25, 31,
            21, 30, 28, 22, 23, 25, 31, 32, 36, 43, 37, 38, 40, 44, 36, 45, 43, 37, 38, 40, 46, 47, 48, 36, 43, 37, 38,
            40, 36, 45, 43, 37, 38, 40, 36, 45, 43, 37, 38, 40, 46, 36, 45, 43, 37, 38, 40, 46, 47, 54, 58, 55, 59, 54,
            60, 58, 55, 61, 62, 63, 54, 58, 55, 54, 60, 58, 55, 54, 60, 58, 55, 61, 54, 60, 58, 55, 61, 62, 76, 80, 77,
            81, 76, 82, 80, 77, 83, 84, 85, 76, 80, 77, 76, 82, 80, 77, 76, 82, 80, 77, 83, 76, 82, 80, 77, 83, 84, 86,
            91, 87, 88, 92, 86, 93, 91, 87, 88, 94, 95, 96, 86, 91, 87, 88, 86, 93, 91, 87, 88, 86, 93, 91, 87, 88, 94,
            86, 93, 91, 87, 88, 94, 95, 162, 166, 163, 167, 162, 168, 166, 163, 169, 170, 171, 162, 166, 163, 162, 168,
            166, 163, 162, 168, 166, 163, 169, 162, 168, 166, 163, 169, 170, 166, 162, 163, 174, 175, 166, 162, 163,
            176, 177, 178, 166, 162, 163, 175, 166, 162, 163, 175, 166, 162, 163, 176, 175, 166, 162, 163, 176, 177,
            181, 190, 193, 184, 186, 189, 187, 188, 184, 191, 192, 181, 191, 192, 181, 183, 262, 274, 289, 264, 265,
            304, 262, 263, 264, 265, 262, 264, 265, 268, 269, 262, 270, 264, 265, 268, 271, 272, 273, 262, 264, 265,
            268, 262, 270, 264, 265, 268, 262, 270, 264, 265, 268, 271, 262, 270, 264, 265, 268, 271, 272, 275, 276,
            277, 279, 275, 282, 276, 277, 279, 283, 275, 284, 282, 276, 277, 279, 285, 286, 287, 275, 282, 276, 277,
            279, 275, 284, 282, 276, 277, 279, 275, 284, 282, 276, 277, 279, 285, 275, 284, 282, 276, 277, 279, 285,
            286, 290, 291, 292, 294, 290, 297, 291, 292, 294, 298, 290, 299, 297, 291, 292, 294, 300, 301, 302, 290,
            297, 291, 292, 294, 290, 299, 297, 291, 292, 294, 290, 299, 297, 291, 292, 294, 300, 290, 299, 297, 291,
            292, 294, 300, 301, 262, 274, 289, 263, 264, 265, 304, 308, 314, 310, 311, 312, 313, 310, 311, 312, 315,
            319, 323, 327, 331, 335, 310, 333, 334, 310, 336, 337, 338, 310, 336, 337, 318, 344, 345, 346, 318, 344,
            345, 348, 341, 349, 350, 351, 348, 341, 349, 348, 341, 349, 350, 80, 76, 77, 354, 355, 80, 76, 77, 356,
            357, 358, 80, 76, 77, 355, 80, 76, 77, 355, 80, 76, 77, 356, 355, 80, 76, 77, 356, 357, 91, 86, 87, 88,
            360, 361, 91, 86, 87, 88, 362, 363, 364, 91, 86, 87, 88, 361, 91, 86, 87, 88, 361, 91, 86, 87, 88, 362,
            361, 91, 86, 87, 88, 362, 363, 76, 86, 87, 88, 77, 78, 353, 89, 359, 1, 12, 306, 307, 339, 34, 24, 26, 27,
            49, 39, 41, 42, 56, 57, 156, 159, 266, 267, 288, 278, 280, 281, 303, 293, 295, 296,};

    private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) {
        switch (hiByte) {
        case 0:
            return ((jjbitVec2[i2] & l2) != 0L);
        default:
            if ((jjbitVec0[i1] & l1) != 0L) return true;
            return false;
        }
    }

    private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2) {
        switch (hiByte) {
        case 0:
            return ((jjbitVec2[i2] & l2) != 0L);
        default:
            return false;
        }
    }

    public static final String[] jjstrLiteralImages = {"", null, null, null, "\173", "\175", "\54", "\56", "\73",
            "\72", "\52", "\57", "\53", "\55", "\75", "\76", "\133", "\135", "\50", "\51", "\176", null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
            null, null, null, "\74\41\55\55", "\55\55\76", null, "\176\75", "\174\75", "\136\75", "\44\75", "\52\75",
            null, null, null, null, null, null,};

    public static final String[] lexStateNames = {"DEFAULT", "COMMENT",};

    public static final int[] jjnewLexState = {-1, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,};

    static final long[] jjtoToken = {0xe00fc00ffffffff1L, 0x7fffffffL,};

    static final long[] jjtoSkip = {0x4L, 0x0L,};

    static final long[] jjtoMore = {0xaL, 0x0L,};

    protected JavaCharStream input_stream;

    private final int[] jjrounds = new int[365];

    private final int[] jjstateSet = new int[730];

    StringBuffer image;

    int jjimageLen;

    int lengthOfMatch;

    protected char curChar;

    public CueryParserTokenManager(JavaCharStream stream) {
        if (JavaCharStream.staticFlag)
            throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
        input_stream = stream;
    }

    public CueryParserTokenManager(JavaCharStream stream, int lexState) {
        this(stream);
        SwitchTo(lexState);
    }

    public void ReInit(JavaCharStream stream) {
        jjmatchedPos = jjnewStateCnt = 0;
        curLexState = defaultLexState;
        input_stream = stream;
        ReInitRounds();
    }

    private final void ReInitRounds() {
        int i;
        jjround = 0x80000001;
        for (i = 365; i-- > 0;)
            jjrounds[i] = 0x80000000;
    }

    public void ReInit(JavaCharStream stream, int lexState) {
        ReInit(stream);
        SwitchTo(lexState);
    }

    public void SwitchTo(int lexState) {
        if (lexState >= 2 || lexState < 0)
            throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
        else
            curLexState = lexState;
    }

    protected Token jjFillToken() {
        Token t = Token.newToken(jjmatchedKind);
        t.kind = jjmatchedKind;
        String im = jjstrLiteralImages[jjmatchedKind];
        t.image = (im == null) ? input_stream.GetImage() : im;
        t.beginLine = input_stream.getBeginLine();
        t.beginColumn = input_stream.getBeginColumn();
        t.endLine = input_stream.getEndLine();
        t.endColumn = input_stream.getEndColumn();
        return t;
    }

    int curLexState = 0;

    int defaultLexState = 0;

    int jjnewStateCnt;

    int jjround;

    int jjmatchedPos;

    int jjmatchedKind;

    public Token getNextToken() {
        int kind;
        Token specialToken = null;
        Token matchedToken;
        int curPos = 0;

        EOFLoop: for (;;) {
            try {
                curChar = input_stream.BeginToken();
            } catch (java.io.IOException e) {
                jjmatchedKind = 0;
                matchedToken = jjFillToken();
                return matchedToken;
            }
            image = null;
            jjimageLen = 0;

            for (;;) {
                switch (curLexState) {
                case 0:
                    jjmatchedKind = 0x7fffffff;
                    jjmatchedPos = 0;
                    curPos = jjMoveStringLiteralDfa0_0();
                    if (jjmatchedPos == 0 && jjmatchedKind > 94) {
                        jjmatchedKind = 94;
                    }
                    break;
                case 1:
                    jjmatchedKind = 0x7fffffff;
                    jjmatchedPos = 0;
                    curPos = jjMoveStringLiteralDfa0_1();
                    if (jjmatchedPos == 0 && jjmatchedKind > 3) {
                        jjmatchedKind = 3;
                    }
                    break;
                }
                if (jjmatchedKind != 0x7fffffff) {
                    if (jjmatchedPos + 1 < curPos) input_stream.backup(curPos - jjmatchedPos - 1);
                    if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
                        matchedToken = jjFillToken();
                        TokenLexicalActions(matchedToken);
                        if (jjnewLexState[jjmatchedKind] != -1) curLexState = jjnewLexState[jjmatchedKind];
                        return matchedToken;
                    } else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
                        if (jjnewLexState[jjmatchedKind] != -1) curLexState = jjnewLexState[jjmatchedKind];
                        continue EOFLoop;
                    }
                    jjimageLen += jjmatchedPos + 1;
                    if (jjnewLexState[jjmatchedKind] != -1) curLexState = jjnewLexState[jjmatchedKind];
                    curPos = 0;
                    jjmatchedKind = 0x7fffffff;
                    try {
                        curChar = input_stream.readChar();
                        continue;
                    } catch (java.io.IOException e1) {
                    }
                }
                int error_line = input_stream.getEndLine();
                int error_column = input_stream.getEndColumn();
                String error_after = null;
                boolean EOFSeen = false;
                try {
                    input_stream.readChar();
                    input_stream.backup(1);
                } catch (java.io.IOException e1) {
                    EOFSeen = true;
                    error_after = curPos <= 1 ? "" : input_stream.GetImage();
                    if (curChar == '\n' || curChar == '\r') {
                        error_line++;
                        error_column = 0;
                    } else
                        error_column++;
                }
                if (!EOFSeen) {
                    input_stream.backup(1);
                    error_after = curPos <= 1 ? "" : input_stream.GetImage();
                }
                throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
            }
        }
    }

    void TokenLexicalActions(Token matchedToken) {
        switch (jjmatchedKind) {
        case 46:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 1, 1);
            break;
        case 50:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimUrl(image);
            break;
        case 61:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 3);
            break;
        case 62:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 4);
            break;
        case 63:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 3);
            break;
        case 64:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 65:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 66:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 67:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 3);
            break;
        case 68:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 69:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 70:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 71:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 72:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 73:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 74:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 76:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 2);
            break;
        case 77:
            if (image == null) image = new StringBuffer();
            image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
            matchedToken.image = trimBy(image, 0, 1);
            break;
        default:
            break;
        }
    }
}
