/* ELParserTokenManager.java */
/* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
package org.apache.el.parser;

/** Token Manager. */
@SuppressWarnings("all") // Ignore warnings in generated code
public class ELParserTokenManager implements ELParserConstants {
    java.util.Deque<Integer> deque = new java.util.ArrayDeque<Integer>();

    /** Debug output. */
    public java.io.PrintStream debugStream = System.out;

    /** Set debug output. */
    public void setDebugStream(java.io.PrintStream ds) {
        debugStream = ds;
    }

    private final int jjStopStringLiteralDfa_0(int pos, long active0) {
        switch (pos) {
            case 0:
                if ((active0 & 0xcL) != 0L) {
                    jjmatchedKind = 1;
                    return 5;
                }
                return -1;
            default:
                return -1;
        }
    }

    private final int jjStartNfa_0(int pos, long active0) {
        return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
    }

    private int jjStopAtPos(int pos, int kind) {
        jjmatchedKind = kind;
        jjmatchedPos = pos;
        return pos + 1;
    }

    private int jjMoveStringLiteralDfa0_0() {
        switch (curChar) {
            case 35:
                return jjMoveStringLiteralDfa1_0(0x8L);
            case 36:
                return jjMoveStringLiteralDfa1_0(0x4L);
            default:
                return jjMoveNfa_0(7, 0);
        }
    }

    private int jjMoveStringLiteralDfa1_0(long active0) {
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(0, active0);
            return 1;
        }
        switch (curChar) {
            case 123:
                if ((active0 & 0x4L) != 0L) {
                    return jjStopAtPos(1, 2);
                } else if ((active0 & 0x8L) != 0L) {
                    return jjStopAtPos(1, 3);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_0(0, active0);
    }

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

    private int jjMoveNfa_0(int startState, int curPos) {
        int startsAt = 0;
        jjnewStateCnt = 8;
        int i = 1;
        jjstateSet[0] = startState;
        int kind = 0x7fffffff;
        for (;;) {
            if (++jjround == 0x7fffffff) {
                ReInitRounds();
            }
            if (curChar < 64) {
                long l = 1L << curChar;
                do {
                    switch (jjstateSet[--i]) {
                        case 7:
                            if ((0xffffffe7ffffffffL & l) != 0L) {
                                if (kind > 1) {
                                    kind = 1;
                                }
                                {
                                    jjCheckNAddStates(0, 4);
                                }
                            } else if ((0x1800000000L & l) != 0L) {
                                if (kind > 1) {
                                    kind = 1;
                                }
                                {
                                    jjCheckNAdd(5);
                                }
                            }
                            if ((0xffffffe7ffffffffL & l) != 0L) {
                                jjCheckNAddTwoStates(0, 1);
                            }
                            break;
                        case 0:
                            if ((0xffffffe7ffffffffL & l) != 0L) {
                                jjCheckNAddTwoStates(0, 1);
                            }
                            break;
                        case 2:
                            if ((0xffffffe7ffffffffL & l) == 0L) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(0, 4);
                        }
                            break;
                        case 3:
                            if ((0xffffffe7ffffffffL & l) != 0L) {
                                jjCheckNAddTwoStates(3, 4);
                            }
                            break;
                        case 4:
                            if ((0x1800000000L & l) != 0L) {
                                jjCheckNAdd(5);
                            }
                            break;
                        case 5:
                            if ((0xffffffe7ffffffffL & l) == 0L) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(5, 8);
                        }
                            break;
                        case 6:
                            if ((0x1800000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(9, 13);
                        }
                            break;
                        default:
                            break;
                    }
                } while (i != startsAt);
            } else if (curChar < 128) {
                long l = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 7:
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(0, 4);
                        }
                            if ((0xffffffffefffffffL & l) != 0L) {
                                jjCheckNAddTwoStates(0, 1);
                            } else if (curChar == 92) {
                                if (kind > 1) {
                                    kind = 1;
                                }
                                {
                                    jjCheckNAddStates(14, 17);
                                }
                            }
                            break;
                        case 0:
                            if ((0xffffffffefffffffL & l) != 0L) {
                                jjCheckNAddTwoStates(0, 1);
                            }
                            break;
                        case 1:
                            if (curChar != 92) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(14, 17);
                        }
                            break;
                        case 2:
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(0, 4);
                        }
                            break;
                        case 3: {
                            jjCheckNAddTwoStates(3, 4);
                        }
                            break;
                        case 5:
                            if ((0xf7ffffffefffffffL & l) == 0L) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(5, 8);
                        }
                            break;
                        default:
                            break;
                    }
                } while (i != startsAt);
            } else {
                int hiByte = (curChar >> 8);
                int i1 = hiByte >> 6;
                long l1 = 1L << (hiByte & 077);
                int i2 = (curChar & 0xff) >> 6;
                long l2 = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 7:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjCheckNAddTwoStates(0, 1);
                            }
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                if (kind > 1) {
                                    kind = 1;
                                }
                                {
                                    jjCheckNAddStates(0, 4);
                                }
                            }
                            break;
                        case 0:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjCheckNAddTwoStates(0, 1);
                            }
                            break;
                        case 2:
                            if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(0, 4);
                        }
                            break;
                        case 3:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjCheckNAddTwoStates(3, 4);
                            }
                            break;
                        case 5:
                            if (!jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                break;
                            }
                            if (kind > 1) {
                                kind = 1;
                            } {
                            jjCheckNAddStates(5, 8);
                        }
                            break;
                        default:
                            if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) {
                                break;
                            } else {
                                break;
                            }
                    }
                } while (i != startsAt);
            }
            if (kind != 0x7fffffff) {
                jjmatchedKind = kind;
                jjmatchedPos = curPos;
                kind = 0x7fffffff;
            }
            ++curPos;
            if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt))) {
                return curPos;
            }
            try {
                curChar = input_stream.readChar();
            } catch (java.io.IOException e) {
                return curPos;
            }
        }
    }

    private final int jjStopStringLiteralDfa_2(int pos, long active0) {
        switch (pos) {
            case 0:
                if ((active0 & 0x20000L) != 0L) {
                    return 1;
                }
                if ((active0 & 0xa0d555401c000L) != 0L) {
                    jjmatchedKind = 55;
                    return 16;
                }
                return -1;
            case 1:
                if ((active0 & 0xa09400001c000L) != 0L) {
                    jjmatchedKind = 55;
                    jjmatchedPos = 1;
                    return 16;
                }
                if ((active0 & 0x41554000000L) != 0L) {
                    return 16;
                }
                return -1;
            case 2:
                if ((active0 & 0xa014000000000L) != 0L) {
                    return 16;
                }
                if ((active0 & 0x8000001c000L) != 0L) {
                    jjmatchedKind = 55;
                    jjmatchedPos = 2;
                    return 16;
                }
                return -1;
            case 3:
                if ((active0 & 0x14000L) != 0L) {
                    return 16;
                }
                if ((active0 & 0x80000008000L) != 0L) {
                    jjmatchedKind = 55;
                    jjmatchedPos = 3;
                    return 16;
                }
                return -1;
            default:
                return -1;
        }
    }

    private final int jjStartNfa_2(int pos, long active0) {
        return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
    }

    private int jjMoveStringLiteralDfa0_2() {
        switch (curChar) {
            case 33:
                jjmatchedKind = 37;
                return jjMoveStringLiteralDfa1_2(0x800000000L);
            case 37:
                return jjStopAtPos(0, 50);
            case 38:
                return jjMoveStringLiteralDfa1_2(0x8000000000L);
            case 40:
                return jjStopAtPos(0, 18);
            case 41:
                return jjStopAtPos(0, 19);
            case 42:
                return jjStopAtPos(0, 44);
            case 43:
                jjmatchedKind = 45;
                return jjMoveStringLiteralDfa1_2(0x10000000000000L);
            case 44:
                return jjStopAtPos(0, 24);
            case 45:
                jjmatchedKind = 46;
                return jjMoveStringLiteralDfa1_2(0x40000000000000L);
            case 46:
                return jjStartNfaWithStates_2(0, 17, 1);
            case 47:
                return jjStopAtPos(0, 48);
            case 58:
                return jjStopAtPos(0, 22);
            case 59:
                return jjStopAtPos(0, 23);
            case 60:
                jjmatchedKind = 27;
                return jjMoveStringLiteralDfa1_2(0x80000000L);
            case 61:
                jjmatchedKind = 53;
                return jjMoveStringLiteralDfa1_2(0x200000000L);
            case 62:
                jjmatchedKind = 25;
                return jjMoveStringLiteralDfa1_2(0x20000000L);
            case 63:
                return jjStopAtPos(0, 47);
            case 91:
                return jjStopAtPos(0, 20);
            case 93:
                return jjStopAtPos(0, 21);
            case 97:
                return jjMoveStringLiteralDfa1_2(0x10000000000L);
            case 100:
                return jjMoveStringLiteralDfa1_2(0x2000000000000L);
            case 101:
                return jjMoveStringLiteralDfa1_2(0x80400000000L);
            case 102:
                return jjMoveStringLiteralDfa1_2(0x8000L);
            case 103:
                return jjMoveStringLiteralDfa1_2(0x44000000L);
            case 108:
                return jjMoveStringLiteralDfa1_2(0x110000000L);
            case 109:
                return jjMoveStringLiteralDfa1_2(0x8000000000000L);
            case 110:
                return jjMoveStringLiteralDfa1_2(0x5000010000L);
            case 111:
                return jjMoveStringLiteralDfa1_2(0x40000000000L);
            case 116:
                return jjMoveStringLiteralDfa1_2(0x4000L);
            case 123:
                return jjStopAtPos(0, 8);
            case 124:
                return jjMoveStringLiteralDfa1_2(0x20000000000L);
            case 125:
                return jjStopAtPos(0, 9);
            default:
                return jjMoveNfa_2(0, 0);
        }
    }

    private int jjMoveStringLiteralDfa1_2(long active0) {
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_2(0, active0);
            return 1;
        }
        switch (curChar) {
            case 38:
                if ((active0 & 0x8000000000L) != 0L) {
                    return jjStopAtPos(1, 39);
                }
                break;
            case 61:
                if ((active0 & 0x20000000L) != 0L) {
                    return jjStopAtPos(1, 29);
                } else if ((active0 & 0x80000000L) != 0L) {
                    return jjStopAtPos(1, 31);
                } else if ((active0 & 0x200000000L) != 0L) {
                    return jjStopAtPos(1, 33);
                } else if ((active0 & 0x800000000L) != 0L) {
                    return jjStopAtPos(1, 35);
                } else if ((active0 & 0x10000000000000L) != 0L) {
                    return jjStopAtPos(1, 52);
                }
                break;
            case 62:
                if ((active0 & 0x40000000000000L) != 0L) {
                    return jjStopAtPos(1, 54);
                }
                break;
            case 97:
                return jjMoveStringLiteralDfa2_2(active0, 0x8000L);
            case 101:
                if ((active0 & 0x40000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 30, 16);
                } else if ((active0 & 0x100000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 32, 16);
                } else if ((active0 & 0x1000000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 36, 16);
                }
                break;
            case 105:
                return jjMoveStringLiteralDfa2_2(active0, 0x2000000000000L);
            case 109:
                return jjMoveStringLiteralDfa2_2(active0, 0x80000000000L);
            case 110:
                return jjMoveStringLiteralDfa2_2(active0, 0x10000000000L);
            case 111:
                return jjMoveStringLiteralDfa2_2(active0, 0x8004000000000L);
            case 113:
                if ((active0 & 0x400000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 34, 16);
                }
                break;
            case 114:
                if ((active0 & 0x40000000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 42, 16);
                }
                return jjMoveStringLiteralDfa2_2(active0, 0x4000L);
            case 116:
                if ((active0 & 0x4000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 26, 16);
                } else if ((active0 & 0x10000000L) != 0L) {
                    return jjStartNfaWithStates_2(1, 28, 16);
                }
                break;
            case 117:
                return jjMoveStringLiteralDfa2_2(active0, 0x10000L);
            case 124:
                if ((active0 & 0x20000000000L) != 0L) {
                    return jjStopAtPos(1, 41);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_2(0, active0);
    }

    private int jjMoveStringLiteralDfa2_2(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_2(0, old0);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_2(1, active0);
            return 2;
        }
        switch (curChar) {
            case 100:
                if ((active0 & 0x10000000000L) != 0L) {
                    return jjStartNfaWithStates_2(2, 40, 16);
                } else if ((active0 & 0x8000000000000L) != 0L) {
                    return jjStartNfaWithStates_2(2, 51, 16);
                }
                break;
            case 108:
                return jjMoveStringLiteralDfa3_2(active0, 0x18000L);
            case 112:
                return jjMoveStringLiteralDfa3_2(active0, 0x80000000000L);
            case 116:
                if ((active0 & 0x4000000000L) != 0L) {
                    return jjStartNfaWithStates_2(2, 38, 16);
                }
                break;
            case 117:
                return jjMoveStringLiteralDfa3_2(active0, 0x4000L);
            case 118:
                if ((active0 & 0x2000000000000L) != 0L) {
                    return jjStartNfaWithStates_2(2, 49, 16);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_2(1, active0);
    }

    private int jjMoveStringLiteralDfa3_2(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_2(1, old0);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_2(2, active0);
            return 3;
        }
        switch (curChar) {
            case 101:
                if ((active0 & 0x4000L) != 0L) {
                    return jjStartNfaWithStates_2(3, 14, 16);
                }
                break;
            case 108:
                if ((active0 & 0x10000L) != 0L) {
                    return jjStartNfaWithStates_2(3, 16, 16);
                }
                break;
            case 115:
                return jjMoveStringLiteralDfa4_2(active0, 0x8000L);
            case 116:
                return jjMoveStringLiteralDfa4_2(active0, 0x80000000000L);
            default:
                break;
        }
        return jjStartNfa_2(2, active0);
    }

    private int jjMoveStringLiteralDfa4_2(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_2(2, old0);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_2(3, active0);
            return 4;
        }
        switch (curChar) {
            case 101:
                if ((active0 & 0x8000L) != 0L) {
                    return jjStartNfaWithStates_2(4, 15, 16);
                }
                break;
            case 121:
                if ((active0 & 0x80000000000L) != 0L) {
                    return jjStartNfaWithStates_2(4, 43, 16);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_2(3, active0);
    }

    private int jjStartNfaWithStates_2(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_2(state, pos + 1);
    }

    static final long[] jjbitVec3 =
            { 0xfff0000040220002L, 0xffffffffffffdfffL, 0xfffff02f7fffffffL, 0x12000000007fffffL };
    static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL };
    static final long[] jjbitVec5 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x501f0003ffc3L };
    static final long[] jjbitVec6 = { 0x0L, 0x3cdf000000000000L, 0xfffffffbffffd740L, 0xffbfffffffffffffL };
    static final long[] jjbitVec7 =
            { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffc03L, 0xffffffffffffffffL };
    static final long[] jjbitVec8 = { 0xfffe00ffffffffffL, 0xfffffffe027fffffL, 0x80ffL, 0x707ffffff0000L };
    static final long[] jjbitVec9 =
            { 0xffffffff00000800L, 0xfffec000000007ffL, 0xffffffffffffffffL, 0x9c00c060002fffffL };
    static final long[] jjbitVec10 = { 0xfffffffd0000L, 0xffffffffffffe000L, 0x2003fffffffffL, 0x43007fffffffc00L };
    static final long[] jjbitVec11 = { 0x110043fffffL, 0x1ffffffL, 0x1ffd00000000L, 0x0L };
    static final long[] jjbitVec12 =
            { 0x23fffffffffffff0L, 0xfefe0003ff010000L, 0x23c5fdfffff99fe0L, 0x80f0003b0004000L };
    static final long[] jjbitVec13 = { 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbbfe0L, 0x2000300010000L };
    static final long[] jjbitVec14 = { 0x23edfdfffff99fe0L, 0x20003b0000000L, 0x3ffc718d63dc7e8L, 0x200000000010000L };
    static final long[] jjbitVec15 = { 0x23effdfffffddfe0L, 0x303000000L, 0x23effdfffffddfe0L, 0x6000340000000L };
    static final long[] jjbitVec16 = { 0x27fffffffffddfe0L, 0xfc00000300004000L, 0x2ffbfffffc7fffe0L, 0x7fL };
    static final long[] jjbitVec17 = { 0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0xf000005fL };
    static final long[] jjbitVec18 = { 0x1L, 0x1ffffffffeffL, 0x1f00L, 0x0L };
    static final long[] jjbitVec19 =
            { 0x800007ffffffffffL, 0xffe1c0623c3f0000L, 0xffffffff00004003L, 0xf7ffffffffff20bfL };
    static final long[] jjbitVec20 =
            { 0xffffffffffffffffL, 0xffffffff3d7f3dffL, 0x7f3dffffffff3dffL, 0xffffffffff7fff3dL };
    static final long[] jjbitVec21 = { 0xffffffffff3dffffL, 0x7ffffffL, 0xffffffff0000ffffL, 0x1fffffffffffffL };
    static final long[] jjbitVec22 =
            { 0xffffffffffffffffL, 0xffff9fffffffffffL, 0xffffffff07fffffeL, 0x1c7ffffffffffL };
    static final long[] jjbitVec23 = { 0x3ffff0003dfffL, 0x1dfff0003ffffL, 0xfffffffffffffL, 0x18800000L };
    static final long[] jjbitVec24 = { 0xffffffff00000000L, 0xffffffffffffffL, 0xffff05ffffffffffL, 0x3fffffffffffffL };
    static final long[] jjbitVec25 = { 0x1fffffffL, 0x1f3fffffff0000L, 0xfffffffffffL, 0xfeL };
    static final long[] jjbitVec26 = { 0xffffffff007fffffL, 0x1fffffL, 0x8000000000L, 0x0L };
    static final long[] jjbitVec27 = { 0xfffffffffffe0L, 0xfe0L, 0xfc00c001fffffff8L, 0x3fffffffffL };
    static final long[] jjbitVec28 = { 0xfffffffffL, 0x3ffffffffc00e000L, 0x0L, 0x63de0000000000L };
    static final long[] jjbitVec29 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L };
    static final long[] jjbitVec30 =
            { 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL };
    static final long[] jjbitVec31 = { 0x8000000000000000L, 0x8002000000100001L, 0x7ffffff1fff0000L, 0x0L };
    static final long[] jjbitVec32 = { 0xf3ffbd503e2ffc84L, 0xffffffff000043e0L, 0x1ffL, 0x0L };
    static final long[] jjbitVec33 =
            { 0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xc781fffffffffL };
    static final long[] jjbitVec34 = { 0xffff20bfffffffffL, 0x80ffffffffffL, 0x7f7f7f7f007fffffL, 0x7f7f7f7fL };
    static final long[] jjbitVec35 = { 0x800000000000L, 0x0L, 0x0L, 0x0L };
    static final long[] jjbitVec36 =
            { 0x1f3e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffee07fffffL, 0xf7ffffffffffffffL };
    static final long[] jjbitVec37 =
            { 0xfffe3fffffffffe0L, 0xffffffffffffffffL, 0x7ffffff00007fffL, 0xffff000000000000L };
    static final long[] jjbitVec38 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L };
    static final long[] jjbitVec39 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL };
    static final long[] jjbitVec40 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x3fffffffffff0000L };
    static final long[] jjbitVec41 = { 0xc00ffff1fffL, 0x80007fffffffffffL, 0xffffffff00ffffffL, 0xffffffffffffL };
    static final long[] jjbitVec42 = { 0xfffffffcff800000L, 0xffffffffffffffffL, 0x7ff000f79ffL, 0xff00000000000000L };
    static final long[] jjbitVec43 = { 0x1000007fffff7bbL, 0xfffffffffffffL, 0xffffffffffffcL, 0x8fc000000000000L };
    static final long[] jjbitVec44 = { 0xffff003ffffffc00L, 0x1fffffff0000007fL, 0x7fffffffffff0L, 0x8000L };
    static final long[] jjbitVec45 = { 0x1ffffffffffL, 0x47fffff00000ff7L, 0x3e62ffffffffffffL, 0x1c07ff38000005L };
    static final long[] jjbitVec46 = { 0x7f7f007e7e7eL, 0x0L, 0x0L, 0x7ffffffffL };
    static final long[] jjbitVec47 =
            { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffff000fffffffffL, 0xffffffffffff87fL };
    static final long[] jjbitVec48 = { 0xffffffffffffffffL, 0xffff3fffffffffffL, 0xffffffffffffffffL, 0x3ffffffL };
    static final long[] jjbitVec49 =
            { 0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L };
    static final long[] jjbitVec50 =
            { 0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0x1fff0000000000ffL };
    static final long[] jjbitVec51 =
            { 0x18000000000000L, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL };
    static final long[] jjbitVec52 = { 0x87fffffe00000010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL };
    static final long[] jjbitVec53 = { 0x0L, 0x0L, 0x420243cffffffffL, 0xff7fffffff7fffffL };
    static final long[] jjbitVec54 =
            { 0xffffffffffffffffL, 0x3cdfffffffffffffL, 0xfffffffbffffd740L, 0xffbfffffffffffffL };
    static final long[] jjbitVec55 =
            { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffffcfbL, 0xffffffffffffffffL };
    static final long[] jjbitVec56 =
            { 0xfffe00ffffffffffL, 0xfffffffe027fffffL, 0xbffffffffffe80ffL, 0x707ffffff00b6L };
    static final long[] jjbitVec57 =
            { 0xffffffff07ff081fL, 0xffffc3ffffffffffL, 0xffffffffffffffffL, 0x9ffffdffbfefffffL };
    static final long[] jjbitVec58 = { 0xffffffffffff8000L, 0xffffffffffffe7ffL, 0x3ffffffffffffL, 0x43fffffffffffffL };
    static final long[] jjbitVec59 = { 0x3fffffffffffL, 0xfffffffL, 0x1ffd00000000L, 0x7ffffff000000000L };
    static final long[] jjbitVec60 =
            { 0xffffffffffffffffL, 0xfefeffcfffffffffL, 0xf3c5fdfffff99feeL, 0x80fffcfb080799fL };
    static final long[] jjbitVec61 = { 0xd36dfdfffff987eeL, 0x3fffc05e023987L, 0xf3edfdfffffbbfeeL, 0x2ffcf00013bbfL };
    static final long[] jjbitVec62 = { 0xf3edfdfffff99feeL, 0x2ffcfb0c0399fL, 0xc3ffc718d63dc7ecL, 0x200ffc000813dc7L };
    static final long[] jjbitVec63 = { 0xe3effdfffffddfeeL, 0xffcf03603ddfL, 0xf3effdfffffddfecL, 0x6ffcf40603ddfL };
    static final long[] jjbitVec64 =
            { 0xe7fffffffffddfecL, 0xfc00ffcf00807ddfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL };
    static final long[] jjbitVec65 = { 0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0xf3ff3f5fL };
    static final long[] jjbitVec66 = { 0xc2a003ff03000001L, 0xfffe1ffffffffeffL, 0x1ffffffffeffffdfL, 0x40L };
    static final long[] jjbitVec67 =
            { 0xffffffffffffffffL, 0xffffffffffff03ffL, 0xffffffff3fffffffL, 0xf7ffffffffff20bfL };
    static final long[] jjbitVec68 = { 0xffffffffff3dffffL, 0xe7ffffffL, 0xffffffff0000ffffL, 0x1fffffffffffffL };
    static final long[] jjbitVec69 = { 0x1fffff001fdfffL, 0xddfff000fffffL, 0xffffffffffffffffL, 0x3ff388fffffL };
    static final long[] jjbitVec70 = { 0xffffffff03ff3800L, 0xffffffffffffffL, 0xffff07ffffffffffL, 0x3fffffffffffffL };
    static final long[] jjbitVec71 = { 0xfff0fff1fffffffL, 0x1f3fffffffffc0L, 0xffff0fffffffffffL, 0x3ff03ffL };
    static final long[] jjbitVec72 = { 0xffffffff0fffffffL, 0x9fffffff7fffffffL, 0x8003ff03ffL, 0x0L };
    static final long[] jjbitVec73 = { 0xffffffffffffffffL, 0xff80003ff0fffL, 0xffffffffffffffffL, 0xfffffffffffffL };
    static final long[] jjbitVec74 = { 0xffffffffffffffL, 0x3fffffffffffe3ffL, 0x0L, 0x7ffffffff70000L };
    static final long[] jjbitVec75 =
            { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xf000007fffffffffL };
    static final long[] jjbitVec76 = { 0x80007c000000f800L, 0x8002fc1f00100001L, 0x7ffffff1fff0000L, 0x1ffe21fff0000L };
    static final long[] jjbitVec77 =
            { 0xffff7fffffffffffL, 0xffffffff7fffffffL, 0xffffffffffffffffL, 0xff81fffffffffL };
    static final long[] jjbitVec78 =
            { 0xffff20bfffffffffL, 0x800080ffffffffffL, 0x7f7f7f7f007fffffL, 0xffffffff7f7f7f7fL };
    static final long[] jjbitVec79 =
            { 0x1f3efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffee67fffffL, 0xf7ffffffffffffffL };
    static final long[] jjbitVec80 = { 0xfffffff1fffL, 0xbff0ffffffffffffL, 0xffffffff80ffffffL, 0x3ffffffffffffL };
    static final long[] jjbitVec81 = { 0x10000ffffffffffL, 0xfffffffffffffL, 0xffffffffffffffffL, 0x8ffffff03ff001fL };
    static final long[] jjbitVec82 = { 0xffff3fffffffffffL, 0x1fffffff000fffffL, 0xffffffffffffffffL, 0x3ff8001L };
    static final long[] jjbitVec83 = { 0x7fffffffffffffL, 0xc7fffff03ff3fffL, 0xffffffffffffffffL, 0x7cffff38000007L };
    static final long[] jjbitVec84 = { 0x7f7f007e7e7eL, 0x0L, 0x0L, 0x3ff37ffffffffffL };
    static final long[] jjbitVec85 =
            { 0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L };
    static final long[] jjbitVec86 =
            { 0x18007f0000ffffL, 0xffdf02000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL };
    static final long[] jjbitVec87 =
            { 0x87fffffe03ff0010L, 0xffffffc007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL };

    private int jjMoveNfa_2(int startState, int curPos) {
        int startsAt = 0;
        jjnewStateCnt = 29;
        int i = 1;
        jjstateSet[0] = startState;
        int kind = 0x7fffffff;
        for (;;) {
            if (++jjround == 0x7fffffff) {
                ReInitRounds();
            }
            if (curChar < 64) {
                long l = 1L << curChar;
                do {
                    switch (jjstateSet[--i]) {
                        case 0:
                            if ((0x3ff000000000000L & l) != 0L) {
                                if (kind > 10) {
                                    kind = 10;
                                }
                                {
                                    jjCheckNAddStates(18, 22);
                                }
                            } else if (curChar == 36) {
                                if (kind > 55) {
                                    kind = 55;
                                }
                                {
                                    jjCheckNAdd(16);
                                }
                            } else if (curChar == 39) {
                                jjCheckNAddStates(23, 25);
                            } else if (curChar == 34) {
                                jjCheckNAddStates(26, 28);
                            } else if (curChar == 46) {
                                jjCheckNAdd(1);
                            }
                            break;
                        case 1:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAddTwoStates(1, 2);
                        }
                            break;
                        case 3:
                            if ((0x280000000000L & l) != 0L) {
                                jjCheckNAdd(4);
                            }
                            break;
                        case 4:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAdd(4);
                        }
                            break;
                        case 5:
                            if (curChar == 34) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 6:
                            if ((0xfffffffbffffffffL & l) != 0L) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 8:
                            if ((0x8400000000L & l) != 0L) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 9:
                            if (curChar == 34 && kind > 13) {
                                kind = 13;
                            }
                            break;
                        case 10:
                            if (curChar == 39) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 11:
                            if ((0xffffff7fffffffffL & l) != 0L) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 13:
                            if ((0x8400000000L & l) != 0L) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 14:
                            if (curChar == 39 && kind > 13) {
                                kind = 13;
                            }
                            break;
                        case 15:
                            if (curChar != 36) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 16:
                            if ((0x3ff00100fffc1ffL & l) == 0L) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 17:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 10) {
                                kind = 10;
                            } {
                            jjCheckNAddStates(18, 22);
                        }
                            break;
                        case 18:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 10) {
                                kind = 10;
                            } {
                            jjCheckNAdd(18);
                        }
                            break;
                        case 19:
                            if ((0x3ff000000000000L & l) != 0L) {
                                jjCheckNAddTwoStates(19, 20);
                            }
                            break;
                        case 20:
                            if (curChar != 46) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAddTwoStates(21, 22);
                        }
                            break;
                        case 21:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAddTwoStates(21, 22);
                        }
                            break;
                        case 23:
                            if ((0x280000000000L & l) != 0L) {
                                jjCheckNAdd(24);
                            }
                            break;
                        case 24:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAdd(24);
                        }
                            break;
                        case 25:
                            if ((0x3ff000000000000L & l) != 0L) {
                                jjCheckNAddTwoStates(25, 26);
                            }
                            break;
                        case 27:
                            if ((0x280000000000L & l) != 0L) {
                                jjCheckNAdd(28);
                            }
                            break;
                        case 28:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAdd(28);
                        }
                            break;
                        default:
                            break;
                    }
                } while (i != startsAt);
            } else if (curChar < 128) {
                long l = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 0:
                            if ((0x7fffffe87fffffeL & l) == 0L) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 2:
                            if ((0x2000000020L & l) != 0L) {
                                jjAddStates(29, 30);
                            }
                            break;
                        case 6:
                            if ((0xffffffffefffffffL & l) != 0L) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 7:
                            if (curChar == 92) {
                                jjstateSet[jjnewStateCnt++] = 8;
                            }
                            break;
                        case 8:
                            if (curChar == 92) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 11:
                            if ((0xffffffffefffffffL & l) != 0L) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 12:
                            if (curChar == 92) {
                                jjstateSet[jjnewStateCnt++] = 13;
                            }
                            break;
                        case 13:
                            if (curChar == 92) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 16:
                            if ((0x87fffffe87fffffeL & l) == 0L) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 22:
                            if ((0x2000000020L & l) != 0L) {
                                jjAddStates(31, 32);
                            }
                            break;
                        case 26:
                            if ((0x2000000020L & l) != 0L) {
                                jjAddStates(33, 34);
                            }
                            break;
                        default:
                            break;
                    }
                } while (i != startsAt);
            } else {
                int hiByte = (curChar >> 8);
                int i1 = hiByte >> 6;
                long l1 = 1L << (hiByte & 077);
                int i2 = (curChar & 0xff) >> 6;
                long l2 = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 0:
                            if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 6:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjAddStates(26, 28);
                            }
                            break;
                        case 11:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjAddStates(23, 25);
                            }
                            break;
                        case 16:
                            if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        default:
                            if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) {
                                break;
                            } else {
                                break;
                            }
                    }
                } while (i != startsAt);
            }
            if (kind != 0x7fffffff) {
                jjmatchedKind = kind;
                jjmatchedPos = curPos;
                kind = 0x7fffffff;
            }
            ++curPos;
            if ((i = jjnewStateCnt) == (startsAt = 29 - (jjnewStateCnt = startsAt))) {
                return curPos;
            }
            try {
                curChar = input_stream.readChar();
            } catch (java.io.IOException e) {
                return curPos;
            }
        }
    }

    private final int jjStopStringLiteralDfa_1(int pos, long active0) {
        switch (pos) {
            case 0:
                if ((active0 & 0x20000L) != 0L) {
                    return 1;
                }
                if ((active0 & 0xa0d555401c000L) != 0L) {
                    jjmatchedKind = 55;
                    return 16;
                }
                return -1;
            case 1:
                if ((active0 & 0xa09400001c000L) != 0L) {
                    jjmatchedKind = 55;
                    jjmatchedPos = 1;
                    return 16;
                }
                if ((active0 & 0x41554000000L) != 0L) {
                    return 16;
                }
                return -1;
            case 2:
                if ((active0 & 0xa014000000000L) != 0L) {
                    return 16;
                }
                if ((active0 & 0x8000001c000L) != 0L) {
                    jjmatchedKind = 55;
                    jjmatchedPos = 2;
                    return 16;
                }
                return -1;
            case 3:
                if ((active0 & 0x14000L) != 0L) {
                    return 16;
                }
                if ((active0 & 0x80000008000L) != 0L) {
                    jjmatchedKind = 55;
                    jjmatchedPos = 3;
                    return 16;
                }
                return -1;
            default:
                return -1;
        }
    }

    private final int jjStartNfa_1(int pos, long active0) {
        return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
    }

    private int jjMoveStringLiteralDfa0_1() {
        switch (curChar) {
            case 33:
                jjmatchedKind = 37;
                return jjMoveStringLiteralDfa1_1(0x800000000L);
            case 37:
                return jjStopAtPos(0, 50);
            case 38:
                return jjMoveStringLiteralDfa1_1(0x8000000000L);
            case 40:
                return jjStopAtPos(0, 18);
            case 41:
                return jjStopAtPos(0, 19);
            case 42:
                return jjStopAtPos(0, 44);
            case 43:
                jjmatchedKind = 45;
                return jjMoveStringLiteralDfa1_1(0x10000000000000L);
            case 44:
                return jjStopAtPos(0, 24);
            case 45:
                jjmatchedKind = 46;
                return jjMoveStringLiteralDfa1_1(0x40000000000000L);
            case 46:
                return jjStartNfaWithStates_1(0, 17, 1);
            case 47:
                return jjStopAtPos(0, 48);
            case 58:
                return jjStopAtPos(0, 22);
            case 59:
                return jjStopAtPos(0, 23);
            case 60:
                jjmatchedKind = 27;
                return jjMoveStringLiteralDfa1_1(0x80000000L);
            case 61:
                jjmatchedKind = 53;
                return jjMoveStringLiteralDfa1_1(0x200000000L);
            case 62:
                jjmatchedKind = 25;
                return jjMoveStringLiteralDfa1_1(0x20000000L);
            case 63:
                return jjStopAtPos(0, 47);
            case 91:
                return jjStopAtPos(0, 20);
            case 93:
                return jjStopAtPos(0, 21);
            case 97:
                return jjMoveStringLiteralDfa1_1(0x10000000000L);
            case 100:
                return jjMoveStringLiteralDfa1_1(0x2000000000000L);
            case 101:
                return jjMoveStringLiteralDfa1_1(0x80400000000L);
            case 102:
                return jjMoveStringLiteralDfa1_1(0x8000L);
            case 103:
                return jjMoveStringLiteralDfa1_1(0x44000000L);
            case 108:
                return jjMoveStringLiteralDfa1_1(0x110000000L);
            case 109:
                return jjMoveStringLiteralDfa1_1(0x8000000000000L);
            case 110:
                return jjMoveStringLiteralDfa1_1(0x5000010000L);
            case 111:
                return jjMoveStringLiteralDfa1_1(0x40000000000L);
            case 116:
                return jjMoveStringLiteralDfa1_1(0x4000L);
            case 123:
                return jjStopAtPos(0, 8);
            case 124:
                return jjMoveStringLiteralDfa1_1(0x20000000000L);
            case 125:
                return jjStopAtPos(0, 9);
            default:
                return jjMoveNfa_1(0, 0);
        }
    }

    private int jjMoveStringLiteralDfa1_1(long active0) {
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_1(0, active0);
            return 1;
        }
        switch (curChar) {
            case 38:
                if ((active0 & 0x8000000000L) != 0L) {
                    return jjStopAtPos(1, 39);
                }
                break;
            case 61:
                if ((active0 & 0x20000000L) != 0L) {
                    return jjStopAtPos(1, 29);
                } else if ((active0 & 0x80000000L) != 0L) {
                    return jjStopAtPos(1, 31);
                } else if ((active0 & 0x200000000L) != 0L) {
                    return jjStopAtPos(1, 33);
                } else if ((active0 & 0x800000000L) != 0L) {
                    return jjStopAtPos(1, 35);
                } else if ((active0 & 0x10000000000000L) != 0L) {
                    return jjStopAtPos(1, 52);
                }
                break;
            case 62:
                if ((active0 & 0x40000000000000L) != 0L) {
                    return jjStopAtPos(1, 54);
                }
                break;
            case 97:
                return jjMoveStringLiteralDfa2_1(active0, 0x8000L);
            case 101:
                if ((active0 & 0x40000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 30, 16);
                } else if ((active0 & 0x100000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 32, 16);
                } else if ((active0 & 0x1000000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 36, 16);
                }
                break;
            case 105:
                return jjMoveStringLiteralDfa2_1(active0, 0x2000000000000L);
            case 109:
                return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L);
            case 110:
                return jjMoveStringLiteralDfa2_1(active0, 0x10000000000L);
            case 111:
                return jjMoveStringLiteralDfa2_1(active0, 0x8004000000000L);
            case 113:
                if ((active0 & 0x400000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 34, 16);
                }
                break;
            case 114:
                if ((active0 & 0x40000000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 42, 16);
                }
                return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
            case 116:
                if ((active0 & 0x4000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 26, 16);
                } else if ((active0 & 0x10000000L) != 0L) {
                    return jjStartNfaWithStates_1(1, 28, 16);
                }
                break;
            case 117:
                return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
            case 124:
                if ((active0 & 0x20000000000L) != 0L) {
                    return jjStopAtPos(1, 41);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_1(0, active0);
    }

    private int jjMoveStringLiteralDfa2_1(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_1(0, old0);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_1(1, active0);
            return 2;
        }
        switch (curChar) {
            case 100:
                if ((active0 & 0x10000000000L) != 0L) {
                    return jjStartNfaWithStates_1(2, 40, 16);
                } else if ((active0 & 0x8000000000000L) != 0L) {
                    return jjStartNfaWithStates_1(2, 51, 16);
                }
                break;
            case 108:
                return jjMoveStringLiteralDfa3_1(active0, 0x18000L);
            case 112:
                return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L);
            case 116:
                if ((active0 & 0x4000000000L) != 0L) {
                    return jjStartNfaWithStates_1(2, 38, 16);
                }
                break;
            case 117:
                return jjMoveStringLiteralDfa3_1(active0, 0x4000L);
            case 118:
                if ((active0 & 0x2000000000000L) != 0L) {
                    return jjStartNfaWithStates_1(2, 49, 16);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_1(1, active0);
    }

    private int jjMoveStringLiteralDfa3_1(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_1(1, old0);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_1(2, active0);
            return 3;
        }
        switch (curChar) {
            case 101:
                if ((active0 & 0x4000L) != 0L) {
                    return jjStartNfaWithStates_1(3, 14, 16);
                }
                break;
            case 108:
                if ((active0 & 0x10000L) != 0L) {
                    return jjStartNfaWithStates_1(3, 16, 16);
                }
                break;
            case 115:
                return jjMoveStringLiteralDfa4_1(active0, 0x8000L);
            case 116:
                return jjMoveStringLiteralDfa4_1(active0, 0x80000000000L);
            default:
                break;
        }
        return jjStartNfa_1(2, active0);
    }

    private int jjMoveStringLiteralDfa4_1(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_1(2, old0);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_1(3, active0);
            return 4;
        }
        switch (curChar) {
            case 101:
                if ((active0 & 0x8000L) != 0L) {
                    return jjStartNfaWithStates_1(4, 15, 16);
                }
                break;
            case 121:
                if ((active0 & 0x80000000000L) != 0L) {
                    return jjStartNfaWithStates_1(4, 43, 16);
                }
                break;
            default:
                break;
        }
        return jjStartNfa_1(3, active0);
    }

    private int jjStartNfaWithStates_1(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_1(state, pos + 1);
    }

    private int jjMoveNfa_1(int startState, int curPos) {
        int startsAt = 0;
        jjnewStateCnt = 29;
        int i = 1;
        jjstateSet[0] = startState;
        int kind = 0x7fffffff;
        for (;;) {
            if (++jjround == 0x7fffffff) {
                ReInitRounds();
            }
            if (curChar < 64) {
                long l = 1L << curChar;
                do {
                    switch (jjstateSet[--i]) {
                        case 0:
                            if ((0x3ff000000000000L & l) != 0L) {
                                if (kind > 10) {
                                    kind = 10;
                                }
                                {
                                    jjCheckNAddStates(18, 22);
                                }
                            } else if (curChar == 36) {
                                if (kind > 55) {
                                    kind = 55;
                                }
                                {
                                    jjCheckNAdd(16);
                                }
                            } else if (curChar == 39) {
                                jjCheckNAddStates(23, 25);
                            } else if (curChar == 34) {
                                jjCheckNAddStates(26, 28);
                            } else if (curChar == 46) {
                                jjCheckNAdd(1);
                            }
                            break;
                        case 1:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAddTwoStates(1, 2);
                        }
                            break;
                        case 3:
                            if ((0x280000000000L & l) != 0L) {
                                jjCheckNAdd(4);
                            }
                            break;
                        case 4:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAdd(4);
                        }
                            break;
                        case 5:
                            if (curChar == 34) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 6:
                            if ((0xfffffffbffffffffL & l) != 0L) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 8:
                            if ((0x8400000000L & l) != 0L) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 9:
                            if (curChar == 34 && kind > 13) {
                                kind = 13;
                            }
                            break;
                        case 10:
                            if (curChar == 39) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 11:
                            if ((0xffffff7fffffffffL & l) != 0L) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 13:
                            if ((0x8400000000L & l) != 0L) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 14:
                            if (curChar == 39 && kind > 13) {
                                kind = 13;
                            }
                            break;
                        case 15:
                            if (curChar != 36) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 16:
                            if ((0x3ff00100fffc1ffL & l) == 0L) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 17:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 10) {
                                kind = 10;
                            } {
                            jjCheckNAddStates(18, 22);
                        }
                            break;
                        case 18:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 10) {
                                kind = 10;
                            } {
                            jjCheckNAdd(18);
                        }
                            break;
                        case 19:
                            if ((0x3ff000000000000L & l) != 0L) {
                                jjCheckNAddTwoStates(19, 20);
                            }
                            break;
                        case 20:
                            if (curChar != 46) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAddTwoStates(21, 22);
                        }
                            break;
                        case 21:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAddTwoStates(21, 22);
                        }
                            break;
                        case 23:
                            if ((0x280000000000L & l) != 0L) {
                                jjCheckNAdd(24);
                            }
                            break;
                        case 24:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAdd(24);
                        }
                            break;
                        case 25:
                            if ((0x3ff000000000000L & l) != 0L) {
                                jjCheckNAddTwoStates(25, 26);
                            }
                            break;
                        case 27:
                            if ((0x280000000000L & l) != 0L) {
                                jjCheckNAdd(28);
                            }
                            break;
                        case 28:
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 11) {
                                kind = 11;
                            } {
                            jjCheckNAdd(28);
                        }
                            break;
                        default:
                            break;
                    }
                } while (i != startsAt);
            } else if (curChar < 128) {
                long l = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 0:
                            if ((0x7fffffe87fffffeL & l) == 0L) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 2:
                            if ((0x2000000020L & l) != 0L) {
                                jjAddStates(29, 30);
                            }
                            break;
                        case 6:
                            if ((0xffffffffefffffffL & l) != 0L) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 7:
                            if (curChar == 92) {
                                jjstateSet[jjnewStateCnt++] = 8;
                            }
                            break;
                        case 8:
                            if (curChar == 92) {
                                jjCheckNAddStates(26, 28);
                            }
                            break;
                        case 11:
                            if ((0xffffffffefffffffL & l) != 0L) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 12:
                            if (curChar == 92) {
                                jjstateSet[jjnewStateCnt++] = 13;
                            }
                            break;
                        case 13:
                            if (curChar == 92) {
                                jjCheckNAddStates(23, 25);
                            }
                            break;
                        case 16:
                            if ((0x87fffffe87fffffeL & l) == 0L) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 22:
                            if ((0x2000000020L & l) != 0L) {
                                jjAddStates(31, 32);
                            }
                            break;
                        case 26:
                            if ((0x2000000020L & l) != 0L) {
                                jjAddStates(33, 34);
                            }
                            break;
                        default:
                            break;
                    }
                } while (i != startsAt);
            } else {
                int hiByte = (curChar >> 8);
                int i1 = hiByte >> 6;
                long l1 = 1L << (hiByte & 077);
                int i2 = (curChar & 0xff) >> 6;
                long l2 = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 0:
                            if (!jjCanMove_1(hiByte, i1, i2, l1, l2)) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        case 6:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjAddStates(26, 28);
                            }
                            break;
                        case 11:
                            if (jjCanMove_0(hiByte, i1, i2, l1, l2)) {
                                jjAddStates(23, 25);
                            }
                            break;
                        case 16:
                            if (!jjCanMove_2(hiByte, i1, i2, l1, l2)) {
                                break;
                            }
                            if (kind > 55) {
                                kind = 55;
                            } {
                            jjCheckNAdd(16);
                        }
                            break;
                        default:
                            if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) {
                                break;
                            } else {
                                break;
                            }
                    }
                } while (i != startsAt);
            }
            if (kind != 0x7fffffff) {
                jjmatchedKind = kind;
                jjmatchedPos = curPos;
                kind = 0x7fffffff;
            }
            ++curPos;
            if ((i = jjnewStateCnt) == (startsAt = 29 - (jjnewStateCnt = startsAt))) {
                return curPos;
            }
            try {
                curChar = input_stream.readChar();
            } catch (java.io.IOException e) {
                return curPos;
            }
        }
    }

    /** Token literal values. */
    public static final String[] jjstrLiteralImages = { "", null, "\44\173", "\43\173", null, null, null, null, "\173",
            "\175", null, null, null, null, "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\56",
            "\50", "\51", "\133", "\135", "\72", "\73", "\54", "\76", "\147\164", "\74", "\154\164", "\76\75",
            "\147\145", "\74\75", "\154\145", "\75\75", "\145\161", "\41\75", "\156\145", "\41", "\156\157\164",
            "\46\46", "\141\156\144", "\174\174", "\157\162", "\145\155\160\164\171", "\52", "\53", "\55", "\77", "\57",
            "\144\151\166", "\45", "\155\157\144", "\53\75", "\75", "\55\76", null, null, null, null, };

    protected Token jjFillToken() {
        final Token t;
        final String curTokenImage;
        final int beginLine;
        final int endLine;
        final int beginColumn;
        final int endColumn;
        String im = jjstrLiteralImages[jjmatchedKind];
        curTokenImage = (im == null) ? input_stream.GetImage() : im;
        beginLine = input_stream.getBeginLine();
        beginColumn = input_stream.getBeginColumn();
        endLine = input_stream.getEndLine();
        endColumn = input_stream.getEndColumn();
        t = Token.newToken(jjmatchedKind, curTokenImage);

        t.beginLine = beginLine;
        t.endLine = endLine;
        t.beginColumn = beginColumn;
        t.endColumn = endColumn;

        return t;
    }

    static final int[] jjnextStates = { 0, 1, 3, 4, 2, 0, 1, 4, 2, 0, 1, 4, 5, 2, 0, 1, 2, 6, 18, 19, 20, 25, 26, 11,
            12, 14, 6, 7, 9, 3, 4, 23, 24, 27, 28, };

    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 ((jjbitVec4[i2] & l2) != 0L);
            case 2:
                return ((jjbitVec5[i2] & l2) != 0L);
            case 3:
                return ((jjbitVec6[i2] & l2) != 0L);
            case 4:
                return ((jjbitVec7[i2] & l2) != 0L);
            case 5:
                return ((jjbitVec8[i2] & l2) != 0L);
            case 6:
                return ((jjbitVec9[i2] & l2) != 0L);
            case 7:
                return ((jjbitVec10[i2] & l2) != 0L);
            case 8:
                return ((jjbitVec11[i2] & l2) != 0L);
            case 9:
                return ((jjbitVec12[i2] & l2) != 0L);
            case 10:
                return ((jjbitVec13[i2] & l2) != 0L);
            case 11:
                return ((jjbitVec14[i2] & l2) != 0L);
            case 12:
                return ((jjbitVec15[i2] & l2) != 0L);
            case 13:
                return ((jjbitVec16[i2] & l2) != 0L);
            case 14:
                return ((jjbitVec17[i2] & l2) != 0L);
            case 15:
                return ((jjbitVec18[i2] & l2) != 0L);
            case 16:
                return ((jjbitVec19[i2] & l2) != 0L);
            case 18:
                return ((jjbitVec20[i2] & l2) != 0L);
            case 19:
                return ((jjbitVec21[i2] & l2) != 0L);
            case 20:
                return ((jjbitVec0[i2] & l2) != 0L);
            case 22:
                return ((jjbitVec22[i2] & l2) != 0L);
            case 23:
                return ((jjbitVec23[i2] & l2) != 0L);
            case 24:
                return ((jjbitVec24[i2] & l2) != 0L);
            case 25:
                return ((jjbitVec25[i2] & l2) != 0L);
            case 26:
                return ((jjbitVec26[i2] & l2) != 0L);
            case 27:
                return ((jjbitVec27[i2] & l2) != 0L);
            case 28:
                return ((jjbitVec28[i2] & l2) != 0L);
            case 29:
                return ((jjbitVec29[i2] & l2) != 0L);
            case 31:
                return ((jjbitVec30[i2] & l2) != 0L);
            case 32:
                return ((jjbitVec31[i2] & l2) != 0L);
            case 33:
                return ((jjbitVec32[i2] & l2) != 0L);
            case 44:
                return ((jjbitVec33[i2] & l2) != 0L);
            case 45:
                return ((jjbitVec34[i2] & l2) != 0L);
            case 46:
                return ((jjbitVec35[i2] & l2) != 0L);
            case 48:
                return ((jjbitVec36[i2] & l2) != 0L);
            case 49:
                return ((jjbitVec37[i2] & l2) != 0L);
            case 77:
                return ((jjbitVec38[i2] & l2) != 0L);
            case 159:
                return ((jjbitVec39[i2] & l2) != 0L);
            case 164:
                return ((jjbitVec40[i2] & l2) != 0L);
            case 166:
                return ((jjbitVec41[i2] & l2) != 0L);
            case 167:
                return ((jjbitVec42[i2] & l2) != 0L);
            case 168:
                return ((jjbitVec43[i2] & l2) != 0L);
            case 169:
                return ((jjbitVec44[i2] & l2) != 0L);
            case 170:
                return ((jjbitVec45[i2] & l2) != 0L);
            case 171:
                return ((jjbitVec46[i2] & l2) != 0L);
            case 215:
                return ((jjbitVec47[i2] & l2) != 0L);
            case 250:
                return ((jjbitVec48[i2] & l2) != 0L);
            case 251:
                return ((jjbitVec49[i2] & l2) != 0L);
            case 253:
                return ((jjbitVec50[i2] & l2) != 0L);
            case 254:
                return ((jjbitVec51[i2] & l2) != 0L);
            case 255:
                return ((jjbitVec52[i2] & l2) != 0L);
            default:
                if ((jjbitVec3[i1] & l1) != 0L) {
                    return true;
                }
                return false;
        }
    }

    private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2) {
        switch (hiByte) {
            case 0:
                return ((jjbitVec53[i2] & l2) != 0L);
            case 2:
                return ((jjbitVec5[i2] & l2) != 0L);
            case 3:
                return ((jjbitVec54[i2] & l2) != 0L);
            case 4:
                return ((jjbitVec55[i2] & l2) != 0L);
            case 5:
                return ((jjbitVec56[i2] & l2) != 0L);
            case 6:
                return ((jjbitVec57[i2] & l2) != 0L);
            case 7:
                return ((jjbitVec58[i2] & l2) != 0L);
            case 8:
                return ((jjbitVec59[i2] & l2) != 0L);
            case 9:
                return ((jjbitVec60[i2] & l2) != 0L);
            case 10:
                return ((jjbitVec61[i2] & l2) != 0L);
            case 11:
                return ((jjbitVec62[i2] & l2) != 0L);
            case 12:
                return ((jjbitVec63[i2] & l2) != 0L);
            case 13:
                return ((jjbitVec64[i2] & l2) != 0L);
            case 14:
                return ((jjbitVec65[i2] & l2) != 0L);
            case 15:
                return ((jjbitVec66[i2] & l2) != 0L);
            case 16:
                return ((jjbitVec67[i2] & l2) != 0L);
            case 18:
                return ((jjbitVec20[i2] & l2) != 0L);
            case 19:
                return ((jjbitVec68[i2] & l2) != 0L);
            case 20:
                return ((jjbitVec0[i2] & l2) != 0L);
            case 22:
                return ((jjbitVec22[i2] & l2) != 0L);
            case 23:
                return ((jjbitVec69[i2] & l2) != 0L);
            case 24:
                return ((jjbitVec70[i2] & l2) != 0L);
            case 25:
                return ((jjbitVec71[i2] & l2) != 0L);
            case 26:
                return ((jjbitVec72[i2] & l2) != 0L);
            case 27:
                return ((jjbitVec73[i2] & l2) != 0L);
            case 28:
                return ((jjbitVec74[i2] & l2) != 0L);
            case 29:
                return ((jjbitVec75[i2] & l2) != 0L);
            case 31:
                return ((jjbitVec30[i2] & l2) != 0L);
            case 32:
                return ((jjbitVec76[i2] & l2) != 0L);
            case 33:
                return ((jjbitVec32[i2] & l2) != 0L);
            case 44:
                return ((jjbitVec77[i2] & l2) != 0L);
            case 45:
                return ((jjbitVec78[i2] & l2) != 0L);
            case 46:
                return ((jjbitVec35[i2] & l2) != 0L);
            case 48:
                return ((jjbitVec79[i2] & l2) != 0L);
            case 49:
                return ((jjbitVec37[i2] & l2) != 0L);
            case 77:
                return ((jjbitVec38[i2] & l2) != 0L);
            case 159:
                return ((jjbitVec39[i2] & l2) != 0L);
            case 164:
                return ((jjbitVec40[i2] & l2) != 0L);
            case 166:
                return ((jjbitVec80[i2] & l2) != 0L);
            case 167:
                return ((jjbitVec42[i2] & l2) != 0L);
            case 168:
                return ((jjbitVec81[i2] & l2) != 0L);
            case 169:
                return ((jjbitVec82[i2] & l2) != 0L);
            case 170:
                return ((jjbitVec83[i2] & l2) != 0L);
            case 171:
                return ((jjbitVec84[i2] & l2) != 0L);
            case 215:
                return ((jjbitVec47[i2] & l2) != 0L);
            case 250:
                return ((jjbitVec48[i2] & l2) != 0L);
            case 251:
                return ((jjbitVec85[i2] & l2) != 0L);
            case 253:
                return ((jjbitVec50[i2] & l2) != 0L);
            case 254:
                return ((jjbitVec86[i2] & l2) != 0L);
            case 255:
                return ((jjbitVec87[i2] & l2) != 0L);
            default:
                if ((jjbitVec3[i1] & l1) != 0L) {
                    return true;
                }
                return false;
        }
    }

    int curLexState = 0;
    int defaultLexState = 0;
    int jjnewStateCnt;
    int jjround;
    int jjmatchedPos;
    int jjmatchedKind;

    /** Get the next Token. */
    public Token getNextToken() {
        Token matchedToken;
        int curPos = 0;

        EOFLoop:
        for (;;) {
            try {
                curChar = input_stream.BeginToken();
            } catch (Exception e) {
                jjmatchedKind = 0;
                jjmatchedPos = -1;
                matchedToken = jjFillToken();
                return matchedToken;
            }
            image = jjimage;
            image.setLength(0);
            jjimageLen = 0;

            switch (curLexState) {
                case 0:
                    jjmatchedKind = 0x7fffffff;
                    jjmatchedPos = 0;
                    curPos = jjMoveStringLiteralDfa0_0();
                    break;
                case 1:
                    try {
                        input_stream.backup(0);
                        while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) {
                            curChar = input_stream.BeginToken();
                        }
                    } catch (java.io.IOException e1) {
                        continue EOFLoop;
                    }
                    jjmatchedKind = 0x7fffffff;
                    jjmatchedPos = 0;
                    curPos = jjMoveStringLiteralDfa0_1();
                    if (jjmatchedPos == 0 && jjmatchedKind > 58) {
                        jjmatchedKind = 58;
                    }
                    break;
                case 2:
                    try {
                        input_stream.backup(0);
                        while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L) {
                            curChar = input_stream.BeginToken();
                        }
                    } catch (java.io.IOException e1) {
                        continue EOFLoop;
                    }
                    jjmatchedKind = 0x7fffffff;
                    jjmatchedPos = 0;
                    curPos = jjMoveStringLiteralDfa0_2();
                    if (jjmatchedPos == 0 && jjmatchedKind > 58) {
                        jjmatchedKind = 58;
                    }
                    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 (jjnewLexState[jjmatchedKind] != -1) {
                        curLexState = jjnewLexState[jjmatchedKind];
                    }
                    continue EOFLoop;
                }
            }
            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 SkipLexicalActions(Token matchedToken) {
        switch (jjmatchedKind) {
            default:
                break;
        }
    }

    void MoreLexicalActions() {
        jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
        switch (jjmatchedKind) {
            default:
                break;
        }
    }

    void TokenLexicalActions(Token matchedToken) {
        switch (jjmatchedKind) {
            case 2:
                image.append(jjstrLiteralImages[2]);
                lengthOfMatch = jjstrLiteralImages[2].length();
                deque.push(DEFAULT);
                break;
            case 3:
                image.append(jjstrLiteralImages[3]);
                lengthOfMatch = jjstrLiteralImages[3].length();
                deque.push(DEFAULT);
                break;
            case 8:
                image.append(jjstrLiteralImages[8]);
                lengthOfMatch = jjstrLiteralImages[8].length();
                deque.push(curLexState);
                break;
            case 9:
                image.append(jjstrLiteralImages[9]);
                lengthOfMatch = jjstrLiteralImages[9].length();
                SwitchTo(deque.pop());
                break;
            default:
                break;
        }
    }

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

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

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

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

    /** Constructor. */
    public ELParserTokenManager(SimpleCharStream stream) {

        if (SimpleCharStream.staticFlag) {
            throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
        }

        input_stream = stream;
    }

    /** Constructor. */
    public ELParserTokenManager(SimpleCharStream stream, int lexState) {
        ReInit(stream);
        SwitchTo(lexState);
    }

    /** Reinitialise parser. */

    public void ReInit(SimpleCharStream stream) {


        jjmatchedPos = jjnewStateCnt = 0;
        curLexState = defaultLexState;
        input_stream = stream;
        ReInitRounds();
    }

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

    /** Reinitialise parser. */
    public void ReInit(SimpleCharStream stream, int lexState)

    {
        ReInit(stream);
        SwitchTo(lexState);
    }

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


    /** Lexer state names. */
    public static final String[] lexStateNames = { "DEFAULT", "IN_EXPRESSION", "IN_SET_OR_MAP", };

    /** Lex State array. */
    public static final int[] jjnewLexState = { -1, -1, 1, 1, -1, -1, -1, -1, 2, -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 = { 0x4ffffffffffef0fL, };
    static final long[] jjtoSkip = { 0xf0L, };
    static final long[] jjtoSpecial = { 0x0L, };
    static final long[] jjtoMore = { 0x0L, };
    protected SimpleCharStream input_stream;

    private final int[] jjrounds = new int[29];
    private final int[] jjstateSet = new int[2 * 29];
    private final StringBuilder jjimage = new StringBuilder();
    private StringBuilder image = jjimage;
    private int jjimageLen;
    private int lengthOfMatch;
    protected int curChar;
}
