
/* Generated By:JavaCC: Do not edit this line. CmdParserPlayerTokenManager.java */
package atan.parser;

/** Token Manager. */
public class CmdParserPlayerTokenManager implements CmdParserPlayerConstants {
    static final int[] jjnextStates = {28, 35, };

    /** Token literal values. */
    public static final String[] jjstrLiteralImages = {
        "", null, null, null, null, null, null, null, null, null, "\147\157\141\154\151\145", null, "\163\145\154\146",
        "\166\151\145\167\137\155\157\144\145", "\150\151\147\150", "\154\157\167", "\167\151\144\145",
        "\156\141\162\162\157\167", "\156\157\162\155\141\154", "\163\164\141\155\151\156\141", "\163\160\145\145\144",
        "\150\145\141\144\137\141\156\147\154\145", "\153\151\143\153", "\144\141\163\150", "\164\165\162\156",
        "\163\141\171", "\164\165\162\156\137\156\145\143\153",
        "\142\145\146\157\162\145\137\153\151\143\153\137\157\146\146", "\164\151\155\145\137\157\166\145\162",
        "\160\154\141\171\137\157\156", "\144\162\157\160\137\142\141\154\154",
        "\153\151\143\153\137\157\146\146\137\154", "\153\151\143\153\137\157\146\146\137\162",
        "\153\151\143\153\137\151\156\137\154", "\153\151\143\153\137\151\156\137\162",
        "\146\162\145\145\137\153\151\143\153\137\162", "\146\162\145\145\137\153\151\143\153\137\154",
        "\146\162\145\145\137\153\151\143\153\137\146\141\165\154\164\137\162",
        "\146\162\145\145\137\153\151\143\153\137\146\141\165\154\164\137\154",
        "\143\157\162\156\145\162\137\153\151\143\153\137\162", "\143\157\162\156\145\162\137\153\151\143\153\137\154",
        "\147\157\141\154\137\153\151\143\153\137\162", "\147\157\141\154\137\153\151\143\153\137\154", null, null,
        "\146\157\165\154\137\162", "\146\157\165\154\137\154", "\157\146\146\163\151\144\145\137\162",
        "\157\146\146\163\151\144\145\137\154", "\150\141\154\146\137\164\151\155\145", "\164\151\155\145\137\165\160",
        "\164\151\155\145\137\165\160\137\167\151\164\150\157\165\164\137\141\137\164\145\141\155",
        "\164\151\155\145\137\145\170\164\145\156\144\145\144", "\151\154\154\145\147\141\154\137\155\157\144\145",
        "\151\154\154\145\147\141\154\137\143\157\155\155\141\156\144\137\146\157\162\155",
        "\151\154\154\145\147\141\154\137\157\142\152\145\143\164\137\146\157\162\155",
        "\156\157\137\155\157\162\145\137\164\145\141\155\137\157\162\137\160\154\141\171\145\162",
        "\156\157\137\155\157\162\145\137\164\145\141\155\137\157\162\137\160\154\141\171\145\162\137\157\162\137\147\157\141\154\151\145",
        "\162\145\143\157\156\156\145\143\164", "\165\156\153\156\157\167\156\137\143\157\155\155\141\156\144",
        "\164\157\157\137\155\141\156\171\137\155\157\166\145\163",
        "\163\141\151\144\137\164\157\157\137\155\141\156\171\137\155\145\163\163\141\147\145\163", "\155\157\166\145",
        "\143\150\141\156\147\145\137\155\157\144\145", "\143\150\145\143\153\137\142\141\154\154",
        "\163\164\141\162\164", "\162\145\143\157\166\145\162", "\145\141\162",
        "\143\150\141\156\147\145\137\160\154\141\171\145\162\137\164\171\160\145", "\154\157\157\153",
        "\164\145\141\155\137\156\141\155\145\163", "\164\145\141\155\137\147\162\141\160\150\151\143",
        "\156\157\137\164\145\141\155\137\146\157\165\156\144",
        "\156\157\137\163\165\143\150\137\160\154\141\171\145\162",
        "\143\141\156\156\157\164\137\163\165\142\137\167\150\151\154\145\137\160\154\141\171\157\156",
        "\156\157\137\163\165\142\163\137\154\145\146\164",
        "\155\141\170\137\157\146\137\164\150\141\164\137\164\171\160\145\137\157\156\137\146\151\145\154\144",
        "\143\141\156\156\157\164\137\143\150\141\156\147\145\137\147\157\141\154\151\145",
        "\143\150\141\156\147\145\137\166\151\145\167", "\143\141\164\143\150", "\143", "\164", "\162", "\50", "\51",
        "\40", null, null,
    };
    static final long[] jjtoSkip  = {0x1eL, 0x0L, };
    static final long[] jjtoToken = {0xffffffffffffffe1L, 0xffffffL, };

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

    /** Debug output. */
    public java.io.PrintStream debugStream     = System.out;
    int                        defaultLexState = 0;
    private final int[]        jjrounds        = new int[36];
    private final int[]        jjstateSet      = new int[72];
    protected char             curChar;
    protected SimpleCharStream input_stream;
    int                        jjmatchedKind;
    int                        jjmatchedPos;
    int                        jjnewStateCnt;
    int                        jjround;

    /**
     * Constructor.
     * @param stream
     */
    public CmdParserPlayerTokenManager(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.
     * @param stream
     * @param lexState
     */
    public CmdParserPlayerTokenManager(SimpleCharStream stream, int lexState) {
        this(stream);
        SwitchTo(lexState);
    }

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

    /**
     *
     * @param pos
     * @param active0
     * @param active1
     * @return
     */
    private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1) {
        switch (pos) {
            case 0 :
                if ((active0 & 0x60000000400L) != 0L) {
                    jjmatchedKind = 9;
                    return 28;
                }
                if ((active0 & 0x6be38007c2ff7000L) != 0L || (active1 & 0x1b0aL) != 0L) {
                    jjmatchedKind = 86;
                    return 19;
                }
                if ((active0 & 0x607800000000L) != 0L) {
                    jjmatchedKind = 6;
                    return 19;
                }
                if ((active0 & 0x20000000L) != 0L) {
                    jjmatchedKind = 7;
                    return 19;
                }
                if ((active0 & 0x8000L) != 0L || (active1 & 0x20L) != 0L) {
                    jjmatchedKind = 8;
                    return 19;
                }
                if ((active0 & 0x400000000000000L) != 0L || (active1 & 0x40004L) != 0L) {
                    return 10;
                }
                if ((active0 & 0x8000000L) != 0L) {
                    jjmatchedKind = 5;
                    return 19;
                }
                if ((active0 & 0x901c018015000000L) != 0L || (active1 & 0x3e4d1L) != 0L) {
                    return 19;
                }
                return -1;
            case 1 :
                if ((active0 & 0x60000000400L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 1;
                    return 27;
                }
                if ((active0 & 0x400000000000000L) != 0L || (active1 & 0x4L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 1;
                    return 9;
                }
                if ((active0 & 0xfbffe1fffffff000L) != 0L || (active1 & 0xfffbL) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 1;
                    return 19;
                }
                return -1;
            case 2 :
                if ((active0 & 0xffffe1fffdff7000L) != 0L || (active1 & 0xfff7L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 2;
                    return 19;
                }
                if ((active0 & 0x60000000400L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 2;
                    return 26;
                }
                if ((active0 & 0x2008000L) != 0L || (active1 & 0x8L) != 0L) {
                    return 19;
                }
                return -1;
            case 3 :
                if ((active0 & 0xbfffe1f8783e2000L) != 0L || (active1 & 0xffd7L) != 0L) {
                    if (jjmatchedPos != 3) {
                        jjmatchedKind = 86;
                        jjmatchedPos  = 3;
                    }
                    return 19;
                }
                if ((active0 & 0x60000000400L) != 0L) {
                    if (jjmatchedPos != 3) {
                        jjmatchedKind = 86;
                        jjmatchedPos  = 3;
                    }
                    return 25;
                }
                if ((active0 & 0x4000000785c15000L) != 0L || (active1 & 0x20L) != 0L) {
                    return 19;
                }
                return -1;
            case 4 :
                if ((active0 & 0xbfffe1fffc2e2400L) != 0L || (active1 & 0x7fd5L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 4;
                    return 19;
                }
                if ((active0 & 0x60000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 4;
                    return 24;
                }
                if ((active0 & 0x100000L) != 0L || (active1 & 0x8002L) != 0L) {
                    return 19;
                }
                return -1;
            case 5 :
                if ((active0 & 0xbfff87fffc282000L) != 0L || (active1 & 0x7fd5L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 5;
                    return 19;
                }
                if ((active0 & 0x600000060400L) != 0L) {
                    return 19;
                }
                return -1;
            case 6 :
                if ((active0 & 0xbff387ffdc202000L) != 0L || (active1 & 0x7fd1L) != 0L) {
                    if (jjmatchedPos != 6) {
                        jjmatchedKind = 86;
                        jjmatchedPos  = 6;
                    }
                    return 19;
                }
                if ((active0 & 0xc000020080000L) != 0L || (active1 & 0x4L) != 0L) {
                    return 19;
                }
                return -1;
            case 7 :
                if ((active0 & 0xbffb87ffdc202000L) != 0L || (active1 & 0x7fd1L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 7;
                    return 19;
                }
                return -1;
            case 8 :
                if ((active0 & 0xbbf807f988200000L) != 0L || (active1 & 0x7fd1L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 8;
                    return 19;
                }
                if ((active0 & 0x403800654002000L) != 0L) {
                    return 19;
                }
                return -1;
            case 9 :
                if ((active0 & 0xbbf807f808000000L) != 0L || (active1 & 0x7f90L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 9;
                    return 19;
                }
                if ((active0 & 0x180200000L) != 0L || (active1 & 0x41L) != 0L) {
                    return 19;
                }
                return -1;
            case 10 :
                if ((active0 & 0x3bf801e008000000L) != 0L || (active1 & 0x3f90L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 10;
                    return 19;
                }
                if ((active0 & 0x8000061800000000L) != 0L || (active1 & 0x4000L) != 0L) {
                    return 19;
                }
                return -1;
            case 11 :
                if ((active0 & 0x3bd801e008000000L) != 0L || (active1 & 0x3710L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 11;
                    return 19;
                }
                if ((active0 & 0x20000000000000L) != 0L || (active1 & 0x880L) != 0L) {
                    return 19;
                }
                return -1;
            case 12 :
                if ((active0 & 0x3bc8006008000000L) != 0L || (active1 & 0x3610L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 12;
                    return 19;
                }
                if ((active0 & 0x10018000000000L) != 0L || (active1 & 0x100L) != 0L) {
                    return 19;
                }
                return -1;
            case 13 :
                if ((active0 & 0x2bc8006008000000L) != 0L || (active1 & 0x3410L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 13;
                    return 19;
                }
                if ((active0 & 0x1000000000000000L) != 0L || (active1 & 0x200L) != 0L) {
                    return 19;
                }
                return -1;
            case 14 :
                if ((active0 & 0x23c8006000000000L) != 0L || (active1 & 0x3410L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 14;
                    return 19;
                }
                if ((active0 & 0x800000008000000L) != 0L) {
                    return 19;
                }
                return -1;
            case 15 :
                if ((active0 & 0x23c8006000000000L) != 0L || (active1 & 0x3410L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 15;
                    return 19;
                }
                return -1;
            case 16 :
                if ((active0 & 0x23c8000000000000L) != 0L || (active1 & 0x3410L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 16;
                    return 19;
                }
                if ((active0 & 0x6000000000L) != 0L) {
                    return 19;
                }
                return -1;
            case 17 :
                if ((active0 & 0x23c8000000000000L) != 0L || (active1 & 0x3400L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 17;
                    return 19;
                }
                if ((active1 & 0x10L) != 0L) {
                    return 19;
                }
                return -1;
            case 18 :
                if ((active0 & 0x2348000000000000L) != 0L || (active1 & 0x3400L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 18;
                    return 19;
                }
                if ((active0 & 0x80000000000000L) != 0L) {
                    return 19;
                }
                return -1;
            case 19 :
                if ((active0 & 0x2308000000000000L) != 0L || (active1 & 0x1400L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 19;
                    return 19;
                }
                if ((active0 & 0x40000000000000L) != 0L || (active1 & 0x2000L) != 0L) {
                    return 19;
                }
                return -1;
            case 20 :
                if ((active0 & 0x2308000000000000L) != 0L || (active1 & 0x1400L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 20;
                    return 19;
                }
                return -1;
            case 21 :
                if ((active1 & 0x1400L) != 0L) {
                    if (jjmatchedPos != 21) {
                        jjmatchedKind = 86;
                        jjmatchedPos  = 21;
                    }
                    return 19;
                }
                if ((active0 & 0x2308000000000000L) != 0L) {
                    return 19;
                }
                return -1;
            case 22 :
                if ((active1 & 0x400L) != 0L) {
                    return 19;
                }
                if ((active0 & 0x200000000000000L) != 0L || (active1 & 0x1000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 22;
                    return 19;
                }
                return -1;
            case 23 :
                if ((active0 & 0x200000000000000L) != 0L || (active1 & 0x1000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 23;
                    return 19;
                }
                return -1;
            case 24 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 24;
                    return 19;
                }
                if ((active1 & 0x1000L) != 0L) {
                    return 19;
                }
                return -1;
            case 25 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 25;
                    return 19;
                }
                return -1;
            case 26 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 26;
                    return 19;
                }
                return -1;
            case 27 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 27;
                    return 19;
                }
                return -1;
            case 28 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 28;
                    return 19;
                }
                return -1;
            case 29 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 29;
                    return 19;
                }
                return -1;
            case 30 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    jjmatchedKind = 86;
                    jjmatchedPos  = 30;
                    return 19;
                }
                return -1;
            default :
                return -1;
        }
    }

    /**
     *
     * @param pos
     * @param active0
     * @param active1
     * @return
     */
    private final int jjStartNfa_0(int pos, long active0, long active1) {
        return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
    }

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

    /**
     *
     * @return
     */
    private int jjMoveStringLiteralDfa0_0() {
        switch (curChar) {
            case 32 :
                return jjStopAtPos(0, 85);
            case 40 :
                return jjStopAtPos(0, 83);
            case 41 :
                return jjStopAtPos(0, 84);
            case 98 :
                return jjMoveStringLiteralDfa1_0(0x8000000L, 0x0L);
            case 99 :
                jjmatchedKind = 80;
                return jjMoveStringLiteralDfa1_0(0x8000018000000000L, 0xe411L);
            case 100 :
                return jjMoveStringLiteralDfa1_0(0x40800000L, 0x0L);
            case 101 :
                return jjMoveStringLiteralDfa1_0(0x0L, 0x8L);
            case 102 :
                return jjMoveStringLiteralDfa1_0(0x607800000000L, 0x0L);
            case 103 :
                return jjMoveStringLiteralDfa1_0(0x60000000400L, 0x0L);
            case 104 :
                return jjMoveStringLiteralDfa1_0(0x2000000204000L, 0x0L);
            case 105 :
                return jjMoveStringLiteralDfa1_0(0xe0000000000000L, 0x0L);
            case 107 :
                return jjMoveStringLiteralDfa1_0(0x780400000L, 0x0L);
            case 108 :
                return jjMoveStringLiteralDfa1_0(0x8000L, 0x20L);
            case 109 :
                return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x1000L);
            case 110 :
                return jjMoveStringLiteralDfa1_0(0x300000000060000L, 0xb00L);
            case 111 :
                return jjMoveStringLiteralDfa1_0(0x1800000000000L, 0x0L);
            case 112 :
                return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
            case 114 :
                jjmatchedKind = 82;
                return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x4L);
            case 115 :
                return jjMoveStringLiteralDfa1_0(0x2000000002181000L, 0x2L);
            case 116 :
                jjmatchedKind = 81;
                return jjMoveStringLiteralDfa1_0(0x101c000015000000L, 0xc0L);
            case 117 :
                return jjMoveStringLiteralDfa1_0(0x800000000000000L, 0x0L);
            case 118 :
                return jjMoveStringLiteralDfa1_0(0x2000L, 0x0L);
            case 119 :
                return jjMoveStringLiteralDfa1_0(0x10000L, 0x0L);
            default :
                return jjMoveNfa_0(0, 0);
        }
    }

    /**
     *
     * @param active0
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa1_0(long active0, long active1) {
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(0, active0, active1);
            return 1;
        }
        switch (curChar) {
            case 97 :
                return jjMoveStringLiteralDfa2_0(active0, 0x2002000002820000L, active1, 0xb408L);
            case 101 :
                return jjMoveStringLiteralDfa2_0(active0, 0x400000008201000L, active1, 0xc4L);
            case 102 :
                return jjMoveStringLiteralDfa2_0(active0, 0x1800000000000L, active1, 0L);
            case 104 :
                return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000000L, active1, 0x4011L);
            case 105 :
                return jjMoveStringLiteralDfa2_0(active0, 0x1c000790416000L, active1, 0L);
            case 108 :
                return jjMoveStringLiteralDfa2_0(active0, 0xe0000020000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa2_0(active0, 0x800000000000000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa2_0(active0, 0x5300678000048400L, active1, 0xb20L);
            case 112 :
                return jjMoveStringLiteralDfa2_0(active0, 0x100000L, active1, 0L);
            case 114 :
                return jjMoveStringLiteralDfa2_0(active0, 0x7840000000L, active1, 0L);
            case 116 :
                return jjMoveStringLiteralDfa2_0(active0, 0x80000L, active1, 0x2L);
            case 117 :
                return jjMoveStringLiteralDfa2_0(active0, 0x5000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(0, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(0, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(1, active0, active1);
            return 2;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa3_0(active0, 0x300000000000000L, active1, 0xb00L);
            case 97 :
                return jjMoveStringLiteralDfa3_0(active0, 0x8000060020280400L, active1, 0x40d2L);
            case 99 :
                return jjMoveStringLiteralDfa3_0(active0, 0x400000780400000L, active1, 0x4L);
            case 100 :
                return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L);
            case 101 :
                return jjMoveStringLiteralDfa3_0(active0, 0x7800102000L, active1, 0x1L);
            case 102 :
                return jjMoveStringLiteralDfa3_0(active0, 0x1800008000000L, active1, 0L);
            case 103 :
                return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);
            case 105 :
                return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000000L, active1, 0L);
            case 107 :
                return jjMoveStringLiteralDfa3_0(active0, 0x800000000000000L, active1, 0L);
            case 108 :
                return jjMoveStringLiteralDfa3_0(active0, 0xe2000000001000L, active1, 0L);
            case 109 :
                return jjMoveStringLiteralDfa3_0(active0, 0x1c000010000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x2400L);
            case 111 :
                return jjMoveStringLiteralDfa3_0(active0, 0x1000000040000000L, active1, 0x20L);
            case 114 :
                if ((active1 & 0x8L) != 0L) {
                    return jjStartNfaWithStates_0(2, 67, 19);
                }
                return jjMoveStringLiteralDfa3_0(active0, 0x18005060000L, active1, 0L);
            case 115 :
                return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L);
            case 116 :
                return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000L);
            case 117 :
                return jjMoveStringLiteralDfa3_0(active0, 0x600000000000L, active1, 0L);
            case 118 :
                return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000000L, active1, 0L);
            case 119 :
                if ((active0 & 0x8000L) != 0L) {
                    return jjStartNfaWithStates_0(2, 15, 19);
                }
                break;
            case 120 :
                return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000L);
            case 121 :
                if ((active0 & 0x2000000L) != 0L) {
                    return jjStartNfaWithStates_0(2, 25, 19);
                }
                break;
            default :
                break;
        }
        return jjStartNfa_0(1, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(1, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(2, active0, active1);
            return 3;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0x1000L);
            case 99 :
                return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x8001L);
            case 100 :
                return jjMoveStringLiteralDfa4_0(active0, 0x2000000000200000L, active1, 0L);
            case 101 :
                if ((active0 & 0x10000L) != 0L) {
                    return jjStartNfaWithStates_0(3, 16, 19);
                } else if ((active0 & 0x4000000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(3, 62, 19);
                }
                return jjMoveStringLiteralDfa4_0(active0, 0xfc007810100000L, active1, 0L);
            case 102 :
                if ((active0 & 0x1000L) != 0L) {
                    return jjStartNfaWithStates_0(3, 12, 19);
                }
                return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
            case 104 :
                if ((active0 & 0x4000L) != 0L) {
                    return jjStartNfaWithStates_0(3, 14, 19);
                } else if ((active0 & 0x800000L) != 0L) {
                    return jjStartNfaWithStates_0(3, 23, 19);
                }
                break;
            case 107 :
                if ((active0 & 0x400000L) != 0L) {
                    jjmatchedKind = 22;
                    jjmatchedPos  = 3;
                } else if ((active1 & 0x20L) != 0L) {
                    return jjStartNfaWithStates_0(3, 69, 19);
                }
                return jjMoveStringLiteralDfa4_0(active0, 0x780000000L, active1, 0L);
            case 108 :
                return jjMoveStringLiteralDfa4_0(active0, 0x660000000400L, active1, 0L);
            case 109 :
                return jjMoveStringLiteralDfa4_0(active0, 0x3000000000c0000L, active1, 0xc0L);
            case 110 :
                if ((active0 & 0x1000000L) != 0L) {
                    jjmatchedKind = 24;
                    jjmatchedPos  = 3;
                }
                return jjMoveStringLiteralDfa4_0(active0, 0x8800018004000000L, active1, 0x6410L);
            case 111 :
                return jjMoveStringLiteralDfa4_0(active0, 0x400000008000000L, active1, 0x4L);
            case 112 :
                return jjMoveStringLiteralDfa4_0(active0, 0x40000000L, active1, 0L);
            case 114 :
                return jjMoveStringLiteralDfa4_0(active0, 0x20000L, active1, 0x2L);
            case 115 :
                return jjMoveStringLiteralDfa4_0(active0, 0x1800000000000L, active1, 0xa00L);
            case 116 :
                return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x100L);
            case 119 :
                return jjMoveStringLiteralDfa4_0(active0, 0x2000L, active1, 0L);
            case 121 :
                return jjMoveStringLiteralDfa4_0(active0, 0x20000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(2, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(2, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(3, active0, active1);
            return 4;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa5_0(active0, 0x201e667ff4202000L, active1, 0xc0L);
            case 97 :
                return jjMoveStringLiteralDfa5_0(active0, 0x40000L, active1, 0L);
            case 100 :
                if ((active0 & 0x100000L) != 0L) {
                    return jjStartNfaWithStates_0(4, 20, 19);
                }
                break;
            case 101 :
                return jjMoveStringLiteralDfa5_0(active0, 0x18000000000L, active1, 0x100L);
            case 103 :
                return jjMoveStringLiteralDfa5_0(active0, 0x80e0000000000000L, active1, 0x4010L);
            case 104 :
                if ((active1 & 0x8000L) != 0L) {
                    return jjStartNfaWithStates_0(4, 79, 19);
                }
                break;
            case 105 :
                return jjMoveStringLiteralDfa5_0(active0, 0x1800000080400L, active1, 0L);
            case 107 :
                return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1L);
            case 109 :
                return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa5_0(active0, 0xb00000000020000L, active1, 0x3400L);
            case 114 :
                return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L);
            case 116 :
                if ((active1 & 0x2L) != 0L) {
                    return jjStartNfaWithStates_0(4, 65, 19);
                }
                break;
            case 117 :
                return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0xa00L);
            case 118 :
                return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x4L);
            default :
                break;
        }
        return jjStartNfa_0(3, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private 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 95 :
                return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x1L);
            case 97 :
                return jjMoveStringLiteralDfa6_0(active0, 0x10e0000000200000L, active1, 0x100L);
            case 98 :
                return jjMoveStringLiteralDfa6_0(active0, 0x40000000L, active1, 0x800L);
            case 99 :
                return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x200L);
            case 100 :
                return jjMoveStringLiteralDfa6_0(active0, 0x1800000000000L, active1, 0L);
            case 101 :
                if ((active0 & 0x400L) != 0L) {
                    return jjStartNfaWithStates_0(5, 10, 19);
                }
                return jjMoveStringLiteralDfa6_0(active0, 0x8010000008000000L, active1, 0x4014L);
            case 102 :
                return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x1000L);
            case 103 :
                return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x80L);
            case 105 :
                return jjMoveStringLiteralDfa6_0(active0, 0x600000000L, active1, 0L);
            case 107 :
                return jjMoveStringLiteralDfa6_0(active0, 0x67800000000L, active1, 0L);
            case 108 :
                if ((active0 & 0x40000L) != 0L) {
                    return jjStartNfaWithStates_0(5, 18, 19);
                } else if ((active0 & 0x400000000000L) != 0L) {
                    return jjStartNfaWithStates_0(5, 46, 19);
                }
                break;
            case 109 :
                return jjMoveStringLiteralDfa6_0(active0, 0x2000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa6_0(active0, 0x400000004080000L, active1, 0x40L);
            case 111 :
                return jjMoveStringLiteralDfa6_0(active0, 0x1b0000000L, active1, 0L);
            case 114 :
                if ((active0 & 0x200000000000L) != 0L) {
                    return jjStartNfaWithStates_0(5, 45, 19);
                }
                return jjMoveStringLiteralDfa6_0(active0, 0x300018000000000L, active1, 0L);
            case 116 :
                return jjMoveStringLiteralDfa6_0(active0, 0x2002000000000000L, active1, 0x2400L);
            case 117 :
                return jjMoveStringLiteralDfa6_0(active0, 0xc000000000000L, active1, 0L);
            case 119 :
                if ((active0 & 0x20000L) != 0L) {
                    return jjStartNfaWithStates_0(5, 17, 19);
                }
                return jjMoveStringLiteralDfa6_0(active0, 0x800000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(4, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private 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 95 :
                return jjMoveStringLiteralDfa7_0(active0, 0x8000018008000000L, active1, 0x7410L);
            case 97 :
                if ((active0 & 0x80000L) != 0L) {
                    return jjStartNfaWithStates_0(6, 19, 19);
                }
                return jjMoveStringLiteralDfa7_0(active0, 0x40000000L, active1, 0x40L);
            case 98 :
                return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1L);
            case 101 :
                return jjMoveStringLiteralDfa7_0(active0, 0x701800004000000L, active1, 0L);
            case 102 :
                return jjMoveStringLiteralDfa7_0(active0, 0x180000000L, active1, 0L);
            case 104 :
                return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x200L);
            case 105 :
                return jjMoveStringLiteralDfa7_0(active0, 0x2067800000000L, active1, 0L);
            case 108 :
                return jjMoveStringLiteralDfa7_0(active0, 0xe0000000000000L, active1, 0L);
            case 109 :
                return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x100L);
            case 110 :
                if ((active0 & 0x20000000L) != 0L) {
                    return jjStartNfaWithStates_0(6, 29, 19);
                }
                return jjMoveStringLiteralDfa7_0(active0, 0x1800000600200000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa7_0(active0, 0x2000000000002000L, active1, 0L);
            case 112 :
                if ((active0 & 0x4000000000000L) != 0L) {
                    jjmatchedKind = 50;
                    jjmatchedPos  = 6;
                }
                return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000L, active1, 0L);
            case 114 :
                if ((active1 & 0x4L) != 0L) {
                    return jjStartNfaWithStates_0(6, 66, 19);
                }
                return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x80L);
            case 115 :
                return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x800L);
            case 118 :
                return jjMoveStringLiteralDfa7_0(active0, 0x10000000L, active1, 0L);
            case 120 :
                return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(5, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private 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, active1);
            return 7;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa8_0(active0, 0xbe9800600000000L, active1, 0xb00L);
            case 97 :
                return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x81L);
            case 99 :
                return jjMoveStringLiteralDfa8_0(active0, 0x400067804000000L, active1, 0x2000L);
            case 100 :
                return jjMoveStringLiteralDfa8_0(active0, 0x2000L, active1, 0L);
            case 101 :
                return jjMoveStringLiteralDfa8_0(active0, 0x10000000L, active1, 0L);
            case 102 :
                return jjMoveStringLiteralDfa8_0(active0, 0x180000000L, active1, 0L);
            case 103 :
                return jjMoveStringLiteralDfa8_0(active0, 0x200000L, active1, 0L);
            case 107 :
                return jjMoveStringLiteralDfa8_0(active0, 0x18008000000L, active1, 0L);
            case 108 :
                return jjMoveStringLiteralDfa8_0(active0, 0x40000000L, active1, 0L);
            case 109 :
                return jjMoveStringLiteralDfa8_0(active0, 0x8002000000000000L, active1, 0x40L);
            case 111 :
                return jjMoveStringLiteralDfa8_0(active0, 0x2000000000000000L, active1, 0L);
            case 112 :
                return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x10L);
            case 115 :
                return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x400L);
            case 116 :
                return jjMoveStringLiteralDfa8_0(active0, 0x10000000000000L, active1, 0x1000L);
            case 118 :
                return jjMoveStringLiteralDfa8_0(active0, 0L, active1, 0x4000L);
            case 121 :
                return jjMoveStringLiteralDfa8_0(active0, 0x1000000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(6, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(6, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(7, active0, active1);
            return 8;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa9_0(active0, 0x3000000180000000L, active1, 0L);
            case 99 :
                return jjMoveStringLiteralDfa9_0(active0, 0x840000000000000L, active1, 0L);
            case 101 :
                if ((active0 & 0x2000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 13, 19);
                } else if ((active0 & 0x2000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 49, 19);
                }
                return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L, active1, 0x40L);
            case 102 :
                return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x100L);
            case 104 :
                return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x3000L);
            case 105 :
                return jjMoveStringLiteralDfa9_0(active0, 0x18008000000L, active1, 0x4000L);
            case 107 :
                if ((active0 & 0x4000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 26, 19);
                }
                return jjMoveStringLiteralDfa9_0(active0, 0x67800000000L, active1, 0L);
            case 108 :
                if ((active0 & 0x40000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 30, 19);
                } else if ((active0 & 0x200000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 33, 19);
                } else if ((active0 & 0x1000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 48, 19);
                }
                return jjMoveStringLiteralDfa9_0(active0, 0x200000L, active1, 0x811L);
            case 109 :
                return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa9_0(active0, 0x8080000000000000L, active1, 0L);
            case 112 :
                return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x280L);
            case 114 :
                if ((active0 & 0x10000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 28, 19);
                } else if ((active0 & 0x400000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 34, 19);
                } else if ((active0 & 0x800000000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 47, 19);
                }
                break;
            case 116 :
                if ((active0 & 0x400000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(8, 58, 19);
                }
                return jjMoveStringLiteralDfa9_0(active0, 0x300000000000000L, active1, 0L);
            case 117 :
                return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x400L);
            case 119 :
                return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(7, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(7, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(8, active0, active1);
            return 9;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa10_0(active0, 0x67800000000L, active1, 0L);
            case 97 :
                return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x3010L);
            case 98 :
                return jjMoveStringLiteralDfa10_0(active0, 0x80000000000000L, active1, 0x400L);
            case 99 :
                return jjMoveStringLiteralDfa10_0(active0, 0x18008000000L, active1, 0L);
            case 100 :
                return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000000L, active1, 0L);
            case 101 :
                if ((active0 & 0x200000L) != 0L) {
                    return jjStartNfaWithStates_0(9, 21, 19);
                }
                return jjMoveStringLiteralDfa10_0(active0, 0x300000000000000L, active1, 0x4800L);
            case 104 :
                return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x80L);
            case 105 :
                return jjMoveStringLiteralDfa10_0(active0, 0x8000000000000L, active1, 0L);
            case 108 :
                if ((active0 & 0x80000000L) != 0L) {
                    return jjStartNfaWithStates_0(9, 31, 19);
                } else if ((active1 & 0x1L) != 0L) {
                    return jjStartNfaWithStates_0(9, 64, 19);
                }
                return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x200L);
            case 109 :
                return jjMoveStringLiteralDfa10_0(active0, 0x3000000000000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa10_0(active0, 0x860000000000000L, active1, 0x100L);
            case 114 :
                if ((active0 & 0x100000000L) != 0L) {
                    return jjStartNfaWithStates_0(9, 32, 19);
                }
                break;
            case 115 :
                if ((active1 & 0x40L) != 0L) {
                    return jjStartNfaWithStates_0(9, 70, 19);
                }
                break;
            default :
                break;
        }
        return jjStartNfa_0(8, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa10_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(8, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(9, active0, active1);
            return 10;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x400L);
            case 97 :
                return jjMoveStringLiteralDfa11_0(active0, 0x2300000000000000L, active1, 0x200L);
            case 100 :
                return jjMoveStringLiteralDfa11_0(active0, 0x30000000000000L, active1, 0L);
            case 101 :
                if ((active0 & 0x8000000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(10, 63, 19);
                }
                break;
            case 102 :
                return jjMoveStringLiteralDfa11_0(active0, 0x6000000000L, active1, 0x800L);
            case 105 :
                return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x80L);
            case 106 :
                return jjMoveStringLiteralDfa11_0(active0, 0x80000000000000L, active1, 0L);
            case 107 :
                return jjMoveStringLiteralDfa11_0(active0, 0x18008000000L, active1, 0L);
            case 108 :
                if ((active0 & 0x1000000000L) != 0L) {
                    return jjStartNfaWithStates_0(10, 36, 19);
                } else if ((active0 & 0x40000000000L) != 0L) {
                    return jjStartNfaWithStates_0(10, 42, 19);
                }
                break;
            case 109 :
                return jjMoveStringLiteralDfa11_0(active0, 0x840000000000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x2000L);
            case 111 :
                return jjMoveStringLiteralDfa11_0(active0, 0x1000000000000000L, active1, 0L);
            case 114 :
                if ((active0 & 0x800000000L) != 0L) {
                    return jjStartNfaWithStates_0(10, 35, 19);
                } else if ((active0 & 0x20000000000L) != 0L) {
                    return jjStartNfaWithStates_0(10, 41, 19);
                }
                break;
            case 116 :
                return jjMoveStringLiteralDfa11_0(active0, 0x8000000000000L, active1, 0x1000L);
            case 117 :
                return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x100L);
            case 119 :
                if ((active1 & 0x4000L) != 0L) {
                    return jjStartNfaWithStates_0(10, 78, 19);
                }
                break;
            case 121 :
                return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x10L);
            default :
                break;
        }
        return jjStartNfa_0(9, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa11_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(9, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(10, active0, active1);
            return 11;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa12_0(active0, 0x18008000000L, active1, 0x1000L);
            case 97 :
                return jjMoveStringLiteralDfa12_0(active0, 0x6000000000L, active1, 0L);
            case 99 :
                if ((active1 & 0x80L) != 0L) {
                    return jjStartNfaWithStates_0(11, 71, 19);
                }
                break;
            case 101 :
                if ((active0 & 0x20000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(11, 53, 19);
                }
                return jjMoveStringLiteralDfa12_0(active0, 0x90000000000000L, active1, 0x10L);
            case 103 :
                return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x2000L);
            case 104 :
                return jjMoveStringLiteralDfa12_0(active0, 0x8000000000000L, active1, 0L);
            case 109 :
                return jjMoveStringLiteralDfa12_0(active0, 0xb40000000000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa12_0(active0, 0x2000000000000000L, active1, 0x100L);
            case 116 :
                if ((active1 & 0x800L) != 0L) {
                    return jjStartNfaWithStates_0(11, 75, 19);
                }
                break;
            case 118 :
                return jjMoveStringLiteralDfa12_0(active0, 0x1000000000000000L, active1, 0L);
            case 119 :
                return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x400L);
            case 121 :
                return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x200L);
            default :
                break;
        }
        return jjStartNfa_0(10, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa12_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(10, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(11, active0, active1);
            return 12;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa13_0(active0, 0x300000000000000L, active1, 0L);
            case 97 :
                return jjMoveStringLiteralDfa13_0(active0, 0x840000000000000L, active1, 0L);
            case 99 :
                return jjMoveStringLiteralDfa13_0(active0, 0x80000000000000L, active1, 0L);
            case 100 :
                if ((active0 & 0x10000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(12, 52, 19);
                } else if ((active1 & 0x100L) != 0L) {
                    return jjStartNfaWithStates_0(12, 72, 19);
                }
                break;
            case 101 :
                return jjMoveStringLiteralDfa13_0(active0, 0x1000000000000000L, active1, 0x2200L);
            case 104 :
                return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x400L);
            case 108 :
                if ((active0 & 0x10000000000L) != 0L) {
                    return jjStartNfaWithStates_0(12, 40, 19);
                }
                break;
            case 111 :
                return jjMoveStringLiteralDfa13_0(active0, 0x8000008000000L, active1, 0L);
            case 114 :
                if ((active0 & 0x8000000000L) != 0L) {
                    return jjStartNfaWithStates_0(12, 39, 19);
                }
                return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x10L);
            case 116 :
                return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x1000L);
            case 117 :
                return jjMoveStringLiteralDfa13_0(active0, 0x6000000000L, active1, 0L);
            case 121 :
                return jjMoveStringLiteralDfa13_0(active0, 0x2000000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(11, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa13_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(11, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(12, active0, active1);
            return 13;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa14_0(active0, 0x2000000000000000L, active1, 0x2010L);
            case 102 :
                return jjMoveStringLiteralDfa14_0(active0, 0x8000000L, active1, 0L);
            case 105 :
                return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x400L);
            case 108 :
                return jjMoveStringLiteralDfa14_0(active0, 0x6000000000L, active1, 0L);
            case 110 :
                return jjMoveStringLiteralDfa14_0(active0, 0x840000000000000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa14_0(active0, 0x300000000000000L, active1, 0L);
            case 114 :
                if ((active1 & 0x200L) != 0L) {
                    return jjStartNfaWithStates_0(13, 73, 19);
                }
                break;
            case 115 :
                if ((active0 & 0x1000000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(13, 60, 19);
                }
                break;
            case 116 :
                return jjMoveStringLiteralDfa14_0(active0, 0x80000000000000L, active1, 0L);
            case 117 :
                return jjMoveStringLiteralDfa14_0(active0, 0x8000000000000L, active1, 0L);
            case 121 :
                return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x1000L);
            default :
                break;
        }
        return jjStartNfa_0(12, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa14_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(12, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(13, active0, active1);
            return 14;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa15_0(active0, 0x80000000000000L, active1, 0L);
            case 100 :
                if ((active0 & 0x800000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(14, 59, 19);
                }
                return jjMoveStringLiteralDfa15_0(active0, 0x40000000000000L, active1, 0L);
            case 102 :
                if ((active0 & 0x8000000L) != 0L) {
                    return jjStartNfaWithStates_0(14, 27, 19);
                }
                break;
            case 103 :
                return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x2000L);
            case 108 :
                return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x400L);
            case 109 :
                return jjMoveStringLiteralDfa15_0(active0, 0x2000000000000000L, active1, 0L);
            case 112 :
                return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x1000L);
            case 114 :
                return jjMoveStringLiteralDfa15_0(active0, 0x300000000000000L, active1, 0L);
            case 116 :
                return jjMoveStringLiteralDfa15_0(active0, 0x8006000000000L, active1, 0x10L);
            default :
                break;
        }
        return jjStartNfa_0(13, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa15_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(13, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(14, active0, active1);
            return 15;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa16_0(active0, 0x348006000000000L, active1, 0L);
            case 101 :
                return jjMoveStringLiteralDfa16_0(active0, 0x2000000000000000L, active1, 0x1400L);
            case 102 :
                return jjMoveStringLiteralDfa16_0(active0, 0x80000000000000L, active1, 0L);
            case 111 :
                return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x2000L);
            case 121 :
                return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x10L);
            default :
                break;
        }
        return jjStartNfa_0(14, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa16_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(14, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(15, active0, active1);
            return 16;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa17_0(active0, 0L, active1, 0x1400L);
            case 97 :
                return jjMoveStringLiteralDfa17_0(active0, 0x8000000000000L, active1, 0x2000L);
            case 102 :
                return jjMoveStringLiteralDfa17_0(active0, 0x40000000000000L, active1, 0L);
            case 108 :
                if ((active0 & 0x4000000000L) != 0L) {
                    return jjStartNfaWithStates_0(16, 38, 19);
                }
                break;
            case 111 :
                return jjMoveStringLiteralDfa17_0(active0, 0x80000000000000L, active1, 0L);
            case 112 :
                return jjMoveStringLiteralDfa17_0(active0, 0x300000000000000L, active1, 0x10L);
            case 114 :
                if ((active0 & 0x2000000000L) != 0L) {
                    return jjStartNfaWithStates_0(16, 37, 19);
                }
                break;
            case 115 :
                return jjMoveStringLiteralDfa17_0(active0, 0x2000000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(15, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa17_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(15, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(16, active0, active1);
            return 17;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa18_0(active0, 0x8000000000000L, active1, 0L);
            case 101 :
                if ((active1 & 0x10L) != 0L) {
                    return jjStartNfaWithStates_0(17, 68, 19);
                }
                break;
            case 108 :
                return jjMoveStringLiteralDfa18_0(active0, 0x300000000000000L, active1, 0x2000L);
            case 111 :
                return jjMoveStringLiteralDfa18_0(active0, 0x40000000000000L, active1, 0x1000L);
            case 112 :
                return jjMoveStringLiteralDfa18_0(active0, 0L, active1, 0x400L);
            case 114 :
                return jjMoveStringLiteralDfa18_0(active0, 0x80000000000000L, active1, 0L);
            case 115 :
                return jjMoveStringLiteralDfa18_0(active0, 0x2000000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(16, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa18_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(16, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(17, active0, active1);
            return 18;
        }
        switch (curChar) {
            case 97 :
                return jjMoveStringLiteralDfa19_0(active0, 0x2300000000000000L, active1, 0L);
            case 105 :
                return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x2000L);
            case 108 :
                return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x400L);
            case 109 :
                if ((active0 & 0x80000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(18, 55, 19);
                }
                break;
            case 110 :
                return jjMoveStringLiteralDfa19_0(active0, 0L, active1, 0x1000L);
            case 114 :
                return jjMoveStringLiteralDfa19_0(active0, 0x40000000000000L, active1, 0L);
            case 116 :
                return jjMoveStringLiteralDfa19_0(active0, 0x8000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(17, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa19_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(17, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(18, active0, active1);
            return 19;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x1000L);
            case 97 :
                return jjMoveStringLiteralDfa20_0(active0, 0L, active1, 0x400L);
            case 101 :
                if ((active1 & 0x2000L) != 0L) {
                    return jjStartNfaWithStates_0(19, 77, 19);
                }
                return jjMoveStringLiteralDfa20_0(active0, 0x8000000000000L, active1, 0L);
            case 103 :
                return jjMoveStringLiteralDfa20_0(active0, 0x2000000000000000L, active1, 0L);
            case 109 :
                if ((active0 & 0x40000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(19, 54, 19);
                }
                break;
            case 121 :
                return jjMoveStringLiteralDfa20_0(active0, 0x300000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(18, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa20_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(18, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(19, active0, active1);
            return 20;
        }
        switch (curChar) {
            case 97 :
                return jjMoveStringLiteralDfa21_0(active0, 0x8000000000000L, active1, 0L);
            case 101 :
                return jjMoveStringLiteralDfa21_0(active0, 0x2300000000000000L, active1, 0L);
            case 102 :
                return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x1000L);
            case 121 :
                return jjMoveStringLiteralDfa21_0(active0, 0L, active1, 0x400L);
            default :
                break;
        }
        return jjStartNfa_0(19, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa21_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(19, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(20, active0, active1);
            return 21;
        }
        switch (curChar) {
            case 105 :
                return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x1000L);
            case 109 :
                if ((active0 & 0x8000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(21, 51, 19);
                }
                break;
            case 111 :
                return jjMoveStringLiteralDfa22_0(active0, 0L, active1, 0x400L);
            case 114 :
                if ((active0 & 0x100000000000000L) != 0L) {
                    jjmatchedKind = 56;
                    jjmatchedPos  = 21;
                }
                return jjMoveStringLiteralDfa22_0(active0, 0x200000000000000L, active1, 0L);
            case 115 :
                if ((active0 & 0x2000000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(21, 61, 19);
                }
                break;
            default :
                break;
        }
        return jjStartNfa_0(20, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa22_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(20, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(21, active0, active1);
            return 22;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa23_0(active0, 0x200000000000000L, active1, 0L);
            case 101 :
                return jjMoveStringLiteralDfa23_0(active0, 0L, active1, 0x1000L);
            case 110 :
                if ((active1 & 0x400L) != 0L) {
                    return jjStartNfaWithStates_0(22, 74, 19);
                }
                break;
            default :
                break;
        }
        return jjStartNfa_0(21, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa23_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(21, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(22, active0, active1);
            return 23;
        }
        switch (curChar) {
            case 108 :
                return jjMoveStringLiteralDfa24_0(active0, 0L, active1, 0x1000L);
            case 111 :
                return jjMoveStringLiteralDfa24_0(active0, 0x200000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(22, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa24_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(22, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(23, active0, active1);
            return 24;
        }
        switch (curChar) {
            case 100 :
                if ((active1 & 0x1000L) != 0L) {
                    return jjStartNfaWithStates_0(24, 76, 19);
                }
                break;
            case 114 :
                return jjMoveStringLiteralDfa25_0(active0, 0x200000000000000L, active1, 0L);
            default :
                break;
        }
        return jjStartNfa_0(23, active0, active1);
    }

    /**
     *
     * @param old0
     * @param active0
     * @param old1
     * @param active1
     * @return
     */
    private int jjMoveStringLiteralDfa25_0(long old0, long active0, long old1, long active1) {
        if (((active0 &= old0) | (active1 &= old1)) == 0L) {
            return jjStartNfa_0(23, old0, old1);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(24, active0, 0L);
            return 25;
        }
        switch (curChar) {
            case 95 :
                return jjMoveStringLiteralDfa26_0(active0, 0x200000000000000L);
            default :
                break;
        }
        return jjStartNfa_0(24, active0, 0L);
    }

    /**
     *
     * @param old0
     * @param active0
     * @return
     */
    private int jjMoveStringLiteralDfa26_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_0(24, old0, 0L);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(25, active0, 0L);
            return 26;
        }
        switch (curChar) {
            case 103 :
                return jjMoveStringLiteralDfa27_0(active0, 0x200000000000000L);
            default :
                break;
        }
        return jjStartNfa_0(25, active0, 0L);
    }

    /**
     *
     * @param old0
     * @param active0
     * @return
     */
    private int jjMoveStringLiteralDfa27_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_0(25, old0, 0L);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(26, active0, 0L);
            return 27;
        }
        switch (curChar) {
            case 111 :
                return jjMoveStringLiteralDfa28_0(active0, 0x200000000000000L);
            default :
                break;
        }
        return jjStartNfa_0(26, active0, 0L);
    }

    /**
     *
     * @param old0
     * @param active0
     * @return
     */
    private int jjMoveStringLiteralDfa28_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_0(26, old0, 0L);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(27, active0, 0L);
            return 28;
        }
        switch (curChar) {
            case 97 :
                return jjMoveStringLiteralDfa29_0(active0, 0x200000000000000L);
            default :
                break;
        }
        return jjStartNfa_0(27, active0, 0L);
    }

    /**
     *
     * @param old0
     * @param active0
     * @return
     */
    private int jjMoveStringLiteralDfa29_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_0(27, old0, 0L);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(28, active0, 0L);
            return 29;
        }
        switch (curChar) {
            case 108 :
                return jjMoveStringLiteralDfa30_0(active0, 0x200000000000000L);
            default :
                break;
        }
        return jjStartNfa_0(28, active0, 0L);
    }

    /**
     *
     * @param old0
     * @param active0
     * @return
     */
    private int jjMoveStringLiteralDfa30_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_0(28, old0, 0L);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(29, active0, 0L);
            return 30;
        }
        switch (curChar) {
            case 105 :
                return jjMoveStringLiteralDfa31_0(active0, 0x200000000000000L);
            default :
                break;
        }
        return jjStartNfa_0(29, active0, 0L);
    }

    /**
     *
     * @param old0
     * @param active0
     * @return
     */
    private int jjMoveStringLiteralDfa31_0(long old0, long active0) {
        if (((active0 &= old0)) == 0L) {
            return jjStartNfa_0(29, old0, 0L);
        }
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            jjStopStringLiteralDfa_0(30, active0, 0L);
            return 31;
        }
        switch (curChar) {
            case 101 :
                if ((active0 & 0x200000000000000L) != 0L) {
                    return jjStartNfaWithStates_0(31, 57, 19);
                }
                break;
            default :
                break;
        }
        return jjStartNfa_0(30, active0, 0L);
    }

    /**
     *
     * @param pos
     * @param kind
     * @param state
     * @return
     */
    private int jjStartNfaWithStates_0(int pos, int kind, int state) {
        jjmatchedKind = kind;
        jjmatchedPos  = pos;
        try {
            curChar = input_stream.readChar();
        } catch (java.io.IOException e) {
            return pos + 1;
        }
        return jjMoveNfa_0(state, pos + 1);
    }

    /**
     *
     * @param startState
     * @param curPos
     * @return
     */
    private int jjMoveNfa_0(int startState, int curPos) {
        int startsAt = 0;
        jjnewStateCnt = 36;
        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 9 :
                        case 19 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 25 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 27 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 10 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 0 :
                        case 20 :
                            if ((0x3ff600000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 87) {
                                kind = 87;
                            }
                            jjCheckNAdd(20);
                            break;
                        case 24 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 26 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 28 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 23 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 43) {
                                kind = 43;
                            }
                            jjstateSet[jjnewStateCnt++] = 23;
                            break;
                        case 30 :
                            if ((0x3ff000000000000L & l) == 0L) {
                                break;
                            }
                            if (kind > 44) {
                                kind = 44;
                            }
                            jjstateSet[jjnewStateCnt++] = 30;
                            break;
                        default :
                            break;
                    }
                } while (i != startsAt);
            } else if (curChar < 128) {
                long l = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        case 9 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 102) {
                                jjstateSet[jjnewStateCnt++] = 8;
                            }
                            break;
                        case 25 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 95) {
                                jjstateSet[jjnewStateCnt++] = 31;
                            }
                            if (curChar == 95) {
                                jjstateSet[jjnewStateCnt++] = 24;
                            }
                            break;
                        case 27 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 97) {
                                jjstateSet[jjnewStateCnt++] = 33;
                            }
                            if (curChar == 97) {
                                jjstateSet[jjnewStateCnt++] = 26;
                            }
                            break;
                        case 10 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 101) {
                                jjstateSet[jjnewStateCnt++] = 9;
                            }
                            break;
                        case 0 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if ((0x8000000080L & l) != 0L) {
                                if (kind > 9) {
                                    kind = 9;
                                }
                            } else if ((0x100000001000L & l) != 0L) {
                                if (kind > 8) {
                                    kind = 8;
                                }
                            } else if ((0x1000000010000L & l) != 0L) {
                                if (kind > 7) {
                                    kind = 7;
                                }
                            } else if ((0x4000000040L & l) != 0L) {
                                if (kind > 6) {
                                    kind = 6;
                                }
                            } else if ((0x400000004L & l) != 0L) {
                                if (kind > 5) {
                                    kind = 5;
                                }
                            } else if (curChar == 82) {
                                jjstateSet[jjnewStateCnt++] = 16;
                            } else if (curChar == 114) {
                                jjstateSet[jjnewStateCnt++] = 10;
                            }
                            if (curChar == 103) {
                                jjAddStates(0, 1);
                            }
                            break;
                        case 24 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 108) {
                                jjstateSet[jjnewStateCnt++] = 29;
                            } else if (curChar == 114) {
                                jjstateSet[jjnewStateCnt++] = 22;
                            }
                            break;
                        case 26 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 108) {
                                jjstateSet[jjnewStateCnt++] = 32;
                            }
                            if (curChar == 108) {
                                jjstateSet[jjnewStateCnt++] = 25;
                            }
                            break;
                        case 28 :
                            if ((0x7fffffe87fffffeL & l) != 0L) {
                                if (kind > 86) {
                                    kind = 86;
                                }
                                jjCheckNAdd(19);
                            }
                            if (curChar == 111) {
                                jjstateSet[jjnewStateCnt++] = 34;
                            }
                            if (curChar == 111) {
                                jjstateSet[jjnewStateCnt++] = 27;
                            }
                            break;
                        case 1 :
                            if ((0x4000000040L & l) != 0L && (kind > 6)) {
                                kind = 6;
                            }
                            break;
                        case 2 :
                            if ((0x1000000010000L & l) != 0L && (kind > 7)) {
                                kind = 7;
                            }
                            break;
                        case 3 :
                            if ((0x100000001000L & l) != 0L && (kind > 8)) {
                                kind = 8;
                            }
                            break;
                        case 4 :
                            if ((0x8000000080L & l) != 0L && (kind > 9)) {
                                kind = 9;
                            }
                            break;
                        case 5 :
                            if ((curChar == 101) && (kind > 11)) {
                                kind = 11;
                            }
                            break;
                        case 6 :
                        case 12 :
                            if (curChar == 101) {
                                jjCheckNAdd(5);
                            }
                            break;
                        case 7 :
                            if (curChar == 114) {
                                jjstateSet[jjnewStateCnt++] = 6;
                            }
                            break;
                        case 8 :
                            if (curChar == 101) {
                                jjstateSet[jjnewStateCnt++] = 7;
                            }
                            break;
                        case 11 :
                            if (curChar == 114) {
                                jjstateSet[jjnewStateCnt++] = 10;
                            }
                            break;
                        case 13 :
                            if (curChar == 114) {
                                jjstateSet[jjnewStateCnt++] = 12;
                            }
                            break;
                        case 14 :
                            if (curChar == 101) {
                                jjstateSet[jjnewStateCnt++] = 13;
                            }
                            break;
                        case 15 :
                            if (curChar == 102) {
                                jjstateSet[jjnewStateCnt++] = 14;
                            }
                            break;
                        case 16 :
                            if (curChar == 101) {
                                jjstateSet[jjnewStateCnt++] = 15;
                            }
                            break;
                        case 17 :
                            if (curChar == 82) {
                                jjstateSet[jjnewStateCnt++] = 16;
                            }
                            break;
                        case 18 :
                            if ((0x7fffffe87fffffeL & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 19 :
                            if ((0x7fffffe87fffffeL & l) == 0L) {
                                break;
                            }
                            if (kind > 86) {
                                kind = 86;
                            }
                            jjCheckNAdd(19);
                            break;
                        case 21 :
                            if (curChar == 103) {
                                jjAddStates(0, 1);
                            }
                            break;
                        case 22 :
                            if (curChar == 95) {
                                jjstateSet[jjnewStateCnt++] = 23;
                            }
                            break;
                        case 29 :
                            if (curChar == 95) {
                                jjstateSet[jjnewStateCnt++] = 30;
                            }
                            break;
                        case 31 :
                            if (curChar == 108) {
                                jjstateSet[jjnewStateCnt++] = 29;
                            }
                            break;
                        case 32 :
                            if (curChar == 95) {
                                jjstateSet[jjnewStateCnt++] = 31;
                            }
                            break;
                        case 33 :
                            if (curChar == 108) {
                                jjstateSet[jjnewStateCnt++] = 32;
                            }
                            break;
                        case 34 :
                            if (curChar == 97) {
                                jjstateSet[jjnewStateCnt++] = 33;
                            }
                            break;
                        case 35 :
                            if (curChar == 111) {
                                jjstateSet[jjnewStateCnt++] = 34;
                            }
                            break;
                        default :
                            break;
                    }
                } while (i != startsAt);
            } else {
                int  i2 = (curChar & 0xff) >> 6;
                long l2 = 1L << (curChar & 077);
                do {
                    switch (jjstateSet[--i]) {
                        default :
                            break;
                    }
                } while (i != startsAt);
            }
            if (kind != 0x7fffffff) {
                jjmatchedKind = kind;
                jjmatchedPos  = curPos;
                kind          = 0x7fffffff;
            }
            ++curPos;
            if ((i = jjnewStateCnt) == (startsAt = 36 - (jjnewStateCnt = startsAt))) {
                return curPos;
            }
            try {
                curChar = input_stream.readChar();
            } catch (java.io.IOException e) {
                return curPos;
            }
        }
    }

    /**
     * Reinitialise parser.
     * @param stream
     */
    public void ReInit(SimpleCharStream stream) {
        jjmatchedPos = jjnewStateCnt = 0;
        curLexState  = defaultLexState;
        input_stream = stream;
        ReInitRounds();
    }

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

    /**
     * Reinitialise parser.
     * @param stream
     * @param lexState
     */
    public void ReInit(SimpleCharStream stream, int lexState) {
        ReInit(stream);
        SwitchTo(lexState);
    }

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

    /**
     *
     * @return
     */
    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;
    }

    /**
     * Get the next Token.
     * @return
     */
    public Token getNextToken() {
        Token matchedToken;
        int   curPos = 0;
        EOFLoop:
        for (;;) {
            try {
                curChar = input_stream.BeginToken();
            } catch (java.io.IOException e) {
                jjmatchedKind = 0;
                matchedToken  = jjFillToken();
                return matchedToken;
            }
            try {
                input_stream.backup(0);
                while ((curChar <= 34) && (0x400002600L & (1L << curChar)) != 0L) {
                    curChar = input_stream.BeginToken();
                }
            } catch (java.io.IOException e1) {
                continue EOFLoop;
            }
            jjmatchedKind = 0x7fffffff;
            jjmatchedPos  = 0;
            curPos        = jjMoveStringLiteralDfa0_0();
            if (jjmatchedKind != 0x7fffffff) {
                if (jjmatchedPos + 1 < curPos) {
                    input_stream.backup(curPos - jjmatchedPos - 1);
                }
                if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
                    matchedToken = jjFillToken();
                    return matchedToken;
                } else {
                    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);
        }
    }

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

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

    /**
     *
     * @param state1
     * @param state2
     */
    private void jjCheckNAddTwoStates(int state1, int state2) {
        jjCheckNAdd(state1);
        jjCheckNAdd(state2);
    }
}
