/* Generated By:JJTree&JavaCC: Do not edit this line. PythonGrammar25.java */
package org.python.pydev.parser.grammar25;

import java.util.ArrayList;
import java.util.List;
import org.python.pydev.parser.IGrammar;
import org.python.pydev.parser.grammarcommon.AbstractJJTPythonGrammarState;
import org.python.pydev.parser.grammarcommon.AbstractPythonGrammar;
import org.python.pydev.parser.grammarcommon.AbstractTokenManager;
import org.python.pydev.parser.grammarcommon.EmptySuiteException;
import org.python.pydev.parser.grammarcommon.IJJTPythonGrammarState;
import org.python.pydev.parser.grammarcommon.ITreeBuilder;
import org.python.pydev.parser.grammarcommon.JJTPythonGrammarState;
import org.python.pydev.parser.grammarcommon.JfpDef;
import org.python.pydev.parser.grammarcommon.WithNameInvalidException;
import org.python.pydev.parser.jython.FastCharStream;
import org.python.pydev.parser.jython.ParseException;
import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.Token;
import org.python.pydev.parser.jython.TokenMgrError;
import org.python.pydev.parser.jython.ast.Import;
import org.python.pydev.parser.jython.ast.ImportFrom;
import org.python.pydev.parser.jython.ast.Name;
import org.python.pydev.parser.jython.ast.Num;
import org.python.pydev.parser.jython.ast.Str;
import org.python.pydev.parser.jython.ast.Suite;
import org.python.pydev.parser.jython.ast.Yield;
import org.python.pydev.parser.jython.ast.modType;
import org.python.pydev.shared_core.string.FastStringBuffer;

public final class PythonGrammar25 extends AbstractPythonGrammar implements /*@bgen(jjtree)*/IGrammar,
        PythonGrammar25Constants {/*@bgen(jjtree)*/
    protected final AbstractJJTPythonGrammarState jjtree = createJJTPythonGrammarState(TreeBuilder25.class);

    private final FastStringBuffer dottedNameStringBuffer = new FastStringBuffer();

    private final ITreeBuilder builder;

    /**
     * @return the current token found.
     */
    protected final Token getCurrentToken() {
        return this.token;
    }

    /**
     * Sets the current token.
     */
    protected final void setCurrentToken(Token t) {
        this.token = t;
    }

    /**
     * @return the jjtree from this grammar
     */
    protected final AbstractJJTPythonGrammarState getJJTree() {
        return jjtree;
    }

    /**
     * @return the special tokens in the token source
     */
    public final List<Object> getTokenSourceSpecialTokensList() {
        return token_source.specialTokens;
    }

    /**
     * @return the jj_lastpos
     */
    protected final Token getJJLastPos() {
        return jj_lastpos;
    }

    private boolean acceptWithStmt = false;

    void handleFutureImports(String importName) {
        if (importName.equals("with_statement")) {
            acceptWithStmt = true;
        }
    }

    //file_input: (NEWLINE | stmt)* ENDMARKER
    final public modType file_input() throws ParseException {
        /*@bgen(jjtree) file_input */
        SimpleNode jjtn000 = builder.openNode(JJTFILE_INPUT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            label_1: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case NEWLINE:
                    case LPAREN:
                    case LBRACE:
                    case LBRACKET:
                    case PLUS:
                    case MINUS:
                    case NOT:
                    case NOT_BOOL:
                    case LAMBDA:
                    case IF:
                    case WHILE:
                    case FOR:
                    case TRY:
                    case DEF:
                    case CLASS:
                    case PRINT:
                    case PASS:
                    case BREAK:
                    case CONTINUE:
                    case RETURN:
                    case YIELD:
                    case IMPORT:
                    case FROM:
                    case DEL:
                    case RAISE:
                    case GLOBAL:
                    case EXEC:
                    case ASSERT:
                    case AS:
                    case WITH:
                    case AT:
                    case NAME:
                    case DECNUMBER:
                    case HEXNUMBER:
                    case OCTNUMBER:
                    case FLOAT:
                    case COMPLEX:
                    case SINGLE_STRING:
                    case SINGLE_STRING2:
                    case TRIPLE_STRING:
                    case TRIPLE_STRING2:
                    case SINGLE_USTRING:
                    case SINGLE_USTRING2:
                    case TRIPLE_USTRING:
                    case TRIPLE_USTRING2:
                    case 136:
                        ;
                        break;
                    default:
                        jj_la1[0] = jj_gen;
                        break label_1;
                }
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case NEWLINE:
                        try {
                            jj_consume_token(NEWLINE);
                        } catch (ParseException e) {
                            handleNoNewline(e);
                        }
                        break;
                    case LPAREN:
                    case LBRACE:
                    case LBRACKET:
                    case PLUS:
                    case MINUS:
                    case NOT:
                    case NOT_BOOL:
                    case LAMBDA:
                    case IF:
                    case WHILE:
                    case FOR:
                    case TRY:
                    case DEF:
                    case CLASS:
                    case PRINT:
                    case PASS:
                    case BREAK:
                    case CONTINUE:
                    case RETURN:
                    case YIELD:
                    case IMPORT:
                    case FROM:
                    case DEL:
                    case RAISE:
                    case GLOBAL:
                    case EXEC:
                    case ASSERT:
                    case AS:
                    case WITH:
                    case AT:
                    case NAME:
                    case DECNUMBER:
                    case HEXNUMBER:
                    case OCTNUMBER:
                    case FLOAT:
                    case COMPLEX:
                    case SINGLE_STRING:
                    case SINGLE_STRING2:
                    case TRIPLE_STRING:
                    case TRIPLE_STRING2:
                    case SINGLE_USTRING:
                    case SINGLE_USTRING2:
                    case TRIPLE_USTRING:
                    case TRIPLE_USTRING2:
                    case 136:
                        stmt();
                        break;
                    default:
                        jj_la1[1] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            }
            try {
                jj_consume_token(0);
            } catch (ParseException e) {
                handleNoEof(e);
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            {
                if (true)
                    return (modType) jjtree.popNode();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    //funcdef: 'def' NAME parameters ':' suite
    final public void funcdef() throws ParseException {
        /*@bgen(jjtree) funcdef */
        SimpleNode jjtn000 = builder.openNode(JJTFUNCDEF);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            decorators();
            jj_consume_token(DEF);
            this.markLastAsSuiteStart();
            Name();
            parameters();
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //@ call, name, attr ... <nl>
    final public void decorators() throws ParseException {
        /*@bgen(jjtree) decorators */
        SimpleNode jjtn000 = builder.openNode(JJTDECORATORS);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            label_2: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case AT:
                        ;
                        break;
                    default:
                        jj_la1[2] = jj_gen;
                        break label_2;
                }
                begin_decorator();
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case LPAREN:
                        grammarActions.markDecoratorWithCall();
                        jj_consume_token(LPAREN);
                        grammarActions.addSpecialToken("(", STRATEGY_BEFORE_NEXT);
                        insidetuporcall();
                        try {
                            grammarActions.findTokenAndAdd(")");
                            jj_consume_token(RPAREN);
                        } catch (ParseException e) {
                            handleRParensNearButNotCurrent(e);
                        }
                        break;
                    default:
                        jj_la1[3] = jj_gen;
                        ;
                }
                try {
                    jj_consume_token(NEWLINE);
                } catch (ParseException e) {
                    handleNoNewline(e);
                }
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_decorator() throws ParseException {
        /*@bgen(jjtree) begin_decorator */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_DECORATOR);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = jj_consume_token(AT);
            grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            dotted_name();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //parameters: '(' [varargslist] ')'
    final public void parameters() throws ParseException {
        grammarActions.findTokenAndAdd("(");
        jj_consume_token(LPAREN);
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case MULTIPLY:
            case POWER:
            case AS:
            case WITH:
            case NAME:
                varargslist();
                break;
            default:
                jj_la1[4] = jj_gen;
                ;
        }
        try {
            grammarActions.findTokenAndAdd(")");
            jj_consume_token(RPAREN);
        } catch (ParseException e) {
            handleRParensNearButNotCurrent(e);
        }
    }

    //varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME] | ('**'|'*' '*') NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
    final public void varargslist() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case AS:
            case WITH:
            case NAME:
                defaultarg();
                label_3: while (true) {
                    if (jj_2_1(2)) {
                        ;
                    } else {
                        break label_3;
                    }
                    grammarActions.findTokenAndAdd(",");
                    jj_consume_token(COMMA);
                    defaultarg();
                }
                if (jj_2_2(3)) {
                    grammarActions.findTokenAndAdd(",");
                    jj_consume_token(COMMA);
                    ExtraArgList();
                } else {
                    ;
                }
                if (jj_2_3(2)) {
                    grammarActions.findTokenAndAdd(",");
                    jj_consume_token(COMMA);
                    ExtraKeywordList();
                } else {
                    ;
                }
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        grammarActions.findTokenAndAdd(",");
                        jj_consume_token(COMMA);
                        break;
                    default:
                        jj_la1[5] = jj_gen;
                        ;
                }
                break;
            case MULTIPLY:
            case POWER:
                if (jj_2_4(2)) {
                    ExtraArgList();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COMMA:
                            grammarActions.findTokenAndAdd(",");
                            jj_consume_token(COMMA);
                            ExtraKeywordList();
                            break;
                        default:
                            jj_la1[6] = jj_gen;
                            ;
                    }
                } else {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case MULTIPLY:
                        case POWER:
                            ExtraKeywordList();
                            break;
                        default:
                            jj_la1[7] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                }
                break;
            default:
                jj_la1[8] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    final public void ExtraArgList() throws ParseException {
        /*@bgen(jjtree) ExtraArgList */
        SimpleNode jjtn000 = builder.openNode(JJTEXTRAARGLIST);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(MULTIPLY);
            grammarActions.addSpecialToken("*", STRATEGY_BEFORE_NEXT);
            Name();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void ExtraKeywordList() throws ParseException {
        /*@bgen(jjtree) ExtraKeywordList */
        SimpleNode jjtn000 = builder.openNode(JJTEXTRAKEYWORDLIST);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case POWER:
                    jj_consume_token(POWER);
                    grammarActions.addSpecialToken("**", STRATEGY_BEFORE_NEXT);
                    break;
                case MULTIPLY:
                    jj_consume_token(MULTIPLY);
                    grammarActions.addSpecialToken("*", STRATEGY_BEFORE_NEXT);
                    grammarActions.addSpecialToken("*", STRATEGY_BEFORE_NEXT);
                    jj_consume_token(MULTIPLY);
                    break;
                default:
                    jj_la1[9] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            Name();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void defaultarg() throws ParseException {
        /*@bgen(jjtree) defaultarg */
        SimpleNode jjtn000 = builder.openNode(JJTDEFAULTARG);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            fpdef();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case EQUAL:
                    temporaryToken = jj_consume_token(EQUAL);
                    grammarActions.addSpecialToPrev(temporaryToken, true);
                    test();
                    break;
                default:
                    jj_la1[10] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //fpdef: NAME | '(' fplist ')'
    final public void fpdef() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case AS:
            case WITH:
            case NAME:
                Name();
                break;
            case LPAREN:
                temporaryToken = grammarActions.createSpecialStr("(");
                jj_consume_token(LPAREN);
                grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
                fplist();
                try {
                    grammarActions.findTokenAndAdd(")");
                    jj_consume_token(RPAREN);
                } catch (ParseException e) {
                    handleRParensNearButNotCurrent(e);
                }
                break;
            default:
                jj_la1[11] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //fplist: fpdef (',' fpdef)* [',']
    final public void fplist() throws ParseException {
        /*@bgen(jjtree) tuple */
        SimpleNode jjtn000 = builder.openNode(JJTTUPLE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            fpdef();
            label_4: while (true) {
                if (jj_2_5(2)) {
                    ;
                } else {
                    break label_4;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                fpdef();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case COMMA:
                    Comma();
                    break;
                default:
                    jj_la1[12] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //stmt: simple_stmt | compound_stmt
    final public void stmt() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case NOT_BOOL:
            case LAMBDA:
            case PRINT:
            case PASS:
            case BREAK:
            case CONTINUE:
            case RETURN:
            case YIELD:
            case IMPORT:
            case FROM:
            case DEL:
            case RAISE:
            case GLOBAL:
            case EXEC:
            case ASSERT:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                Token curr = this.jj_lastpos;
                try {
                    simple_stmt();
                } catch (WithNameInvalidException e) {
                    while (!"with".equals(curr.next.image)) {
                        curr = curr.next;
                        if (curr == null) {
                            {
                                if (true)
                                    throw new RuntimeException(
                                            "Unexpected: with not found when it should be already available");
                            }
                        }
                    }
                    setCurrentToken(curr);
                    with_stmt();
                }
                break;
            case IF:
            case WHILE:
            case FOR:
            case TRY:
            case DEF:
            case CLASS:
            case AT:
                try {
                    compound_stmt();
                } catch (ParseException e) {
                    handleErrorInCompountStmt(e);
                }
                break;
            default:
                jj_la1[13] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
    final public void simple_stmt() throws ParseException {
        small_stmt();
        label_5: while (true) {
            if (jj_2_6(2)) {
                ;
            } else {
                break label_5;
            }
            temporaryToken = jj_consume_token(SEMICOLON);
            grammarActions.addSpecialToken(temporaryToken);
            small_stmt();
        }
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case SEMICOLON:
                temporaryToken = jj_consume_token(SEMICOLON);
                grammarActions.addSpecialToken(temporaryToken);
                break;
            default:
                jj_la1[14] = jj_gen;
                ;
        }
        try {
            jj_consume_token(NEWLINE);
        } catch (ParseException e) {
            handleNoNewline(e);
        }
    }

    //small_stmt: expr_stmt | print_stmt  | del_stmt | pass_stmt | flow_stmt | import_stmt | global_stmt | exec_stmt | assert_stmt
    final public void small_stmt() throws ParseException {
        SimpleNode simpleNode;
        Token spStr;
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case NOT_BOOL:
            case LAMBDA:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                expr_stmt();
                break;
            case PRINT:
                print_stmt();
                break;
            case DEL:
                del_stmt();
                break;
            case PASS:
                spStr = pass_stmt();
                grammarActions.addToPeek(spStr, false);
                break;
            case BREAK:
            case CONTINUE:
            case RETURN:
            case YIELD:
            case RAISE:
                flow_stmt();
                break;
            case IMPORT:
            case FROM:
                import_stmt();
                break;
            case GLOBAL:
                global_stmt();
                break;
            case EXEC:
                exec_stmt();
                break;
            case ASSERT:
                temporaryToken = jj_consume_token(ASSERT);
                assert_stmt();
                grammarActions.addToPeek(temporaryToken, false);
                break;
            default:
                jj_la1[15] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //expr_stmt: testlist (augassign (yield_expr|testlist) |
    //                     ('=' (yield_expr|testlist))*)
    final public void expr_stmt() throws ParseException {
        SmartTestList();
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case PLUSEQ:
                jj_consume_token(PLUSEQ);
                SimpleNode jjtn001 = builder.openNode(JJTAUG_PLUS);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[16] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte001) {
                    if (jjtc001) {
                        jjtree.clearNodeScope(jjtn001);
                        jjtc001 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte001 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte001;
                        }
                    }
                    if (jjte001 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte001;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte001;
                    }
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, 2);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case MINUSEQ:
                jj_consume_token(MINUSEQ);
                SimpleNode jjtn002 = builder.openNode(JJTAUG_MINUS);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[17] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte002) {
                    if (jjtc002) {
                        jjtree.clearNodeScope(jjtn002);
                        jjtc002 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte002 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte002;
                        }
                    }
                    if (jjte002 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte002;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte002;
                    }
                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, 2);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                break;
            case MULTIPLYEQ:
                jj_consume_token(MULTIPLYEQ);
                SimpleNode jjtn003 = builder.openNode(JJTAUG_MULTIPLY);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
                jjtreeOpenNodeScope(jjtn003);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[18] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte003) {
                    if (jjtc003) {
                        jjtree.clearNodeScope(jjtn003);
                        jjtc003 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte003 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte003;
                        }
                    }
                    if (jjte003 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte003;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte003;
                    }
                } finally {
                    if (jjtc003) {
                        jjtree.closeNodeScope(jjtn003, 2);
                        jjtreeCloseNodeScope(jjtn003);
                    }
                }
                break;
            case DIVIDEEQ:
                jj_consume_token(DIVIDEEQ);
                SimpleNode jjtn004 = builder.openNode(JJTAUG_DIVIDE);
                boolean jjtc004 = true;
                jjtree.openNodeScope(jjtn004);
                jjtreeOpenNodeScope(jjtn004);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[19] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte004) {
                    if (jjtc004) {
                        jjtree.clearNodeScope(jjtn004);
                        jjtc004 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte004 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte004;
                        }
                    }
                    if (jjte004 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte004;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte004;
                    }
                } finally {
                    if (jjtc004) {
                        jjtree.closeNodeScope(jjtn004, 2);
                        jjtreeCloseNodeScope(jjtn004);
                    }
                }
                break;
            case FLOORDIVIDEEQ:
                jj_consume_token(FLOORDIVIDEEQ);
                SimpleNode jjtn005 = builder.openNode(JJTAUG_FLOORDIVIDE);
                boolean jjtc005 = true;
                jjtree.openNodeScope(jjtn005);
                jjtreeOpenNodeScope(jjtn005);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[20] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte005) {
                    if (jjtc005) {
                        jjtree.clearNodeScope(jjtn005);
                        jjtc005 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte005 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte005;
                        }
                    }
                    if (jjte005 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte005;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte005;
                    }
                } finally {
                    if (jjtc005) {
                        jjtree.closeNodeScope(jjtn005, 2);
                        jjtreeCloseNodeScope(jjtn005);
                    }
                }
                break;
            case MODULOEQ:
                jj_consume_token(MODULOEQ);
                SimpleNode jjtn006 = builder.openNode(JJTAUG_MODULO);
                boolean jjtc006 = true;
                jjtree.openNodeScope(jjtn006);
                jjtreeOpenNodeScope(jjtn006);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[21] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte006) {
                    if (jjtc006) {
                        jjtree.clearNodeScope(jjtn006);
                        jjtc006 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte006 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte006;
                        }
                    }
                    if (jjte006 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte006;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte006;
                    }
                } finally {
                    if (jjtc006) {
                        jjtree.closeNodeScope(jjtn006, 2);
                        jjtreeCloseNodeScope(jjtn006);
                    }
                }
                break;
            case ANDEQ:
                jj_consume_token(ANDEQ);
                SimpleNode jjtn007 = builder.openNode(JJTAUG_AND);
                boolean jjtc007 = true;
                jjtree.openNodeScope(jjtn007);
                jjtreeOpenNodeScope(jjtn007);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[22] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte007) {
                    if (jjtc007) {
                        jjtree.clearNodeScope(jjtn007);
                        jjtc007 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte007 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte007;
                        }
                    }
                    if (jjte007 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte007;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte007;
                    }
                } finally {
                    if (jjtc007) {
                        jjtree.closeNodeScope(jjtn007, 2);
                        jjtreeCloseNodeScope(jjtn007);
                    }
                }
                break;
            case OREQ:
                jj_consume_token(OREQ);
                SimpleNode jjtn008 = builder.openNode(JJTAUG_OR);
                boolean jjtc008 = true;
                jjtree.openNodeScope(jjtn008);
                jjtreeOpenNodeScope(jjtn008);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[23] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte008) {
                    if (jjtc008) {
                        jjtree.clearNodeScope(jjtn008);
                        jjtc008 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte008 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte008;
                        }
                    }
                    if (jjte008 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte008;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte008;
                    }
                } finally {
                    if (jjtc008) {
                        jjtree.closeNodeScope(jjtn008, 2);
                        jjtreeCloseNodeScope(jjtn008);
                    }
                }
                break;
            case XOREQ:
                jj_consume_token(XOREQ);
                SimpleNode jjtn009 = builder.openNode(JJTAUG_XOR);
                boolean jjtc009 = true;
                jjtree.openNodeScope(jjtn009);
                jjtreeOpenNodeScope(jjtn009);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[24] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte009) {
                    if (jjtc009) {
                        jjtree.clearNodeScope(jjtn009);
                        jjtc009 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte009 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte009;
                        }
                    }
                    if (jjte009 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte009;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte009;
                    }
                } finally {
                    if (jjtc009) {
                        jjtree.closeNodeScope(jjtn009, 2);
                        jjtreeCloseNodeScope(jjtn009);
                    }
                }
                break;
            case LSHIFTEQ:
                jj_consume_token(LSHIFTEQ);
                SimpleNode jjtn010 = builder.openNode(JJTAUG_LSHIFT);
                boolean jjtc010 = true;
                jjtree.openNodeScope(jjtn010);
                jjtreeOpenNodeScope(jjtn010);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[25] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte010) {
                    if (jjtc010) {
                        jjtree.clearNodeScope(jjtn010);
                        jjtc010 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte010 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte010;
                        }
                    }
                    if (jjte010 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte010;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte010;
                    }
                } finally {
                    if (jjtc010) {
                        jjtree.closeNodeScope(jjtn010, 2);
                        jjtreeCloseNodeScope(jjtn010);
                    }
                }
                break;
            case RSHIFTEQ:
                jj_consume_token(RSHIFTEQ);
                SimpleNode jjtn011 = builder.openNode(JJTAUG_RSHIFT);
                boolean jjtc011 = true;
                jjtree.openNodeScope(jjtn011);
                jjtreeOpenNodeScope(jjtn011);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[26] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte011) {
                    if (jjtc011) {
                        jjtree.clearNodeScope(jjtn011);
                        jjtc011 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte011 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte011;
                        }
                    }
                    if (jjte011 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte011;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte011;
                    }
                } finally {
                    if (jjtc011) {
                        jjtree.closeNodeScope(jjtn011, 2);
                        jjtreeCloseNodeScope(jjtn011);
                    }
                }
                break;
            case POWEREQ:
                jj_consume_token(POWEREQ);
                SimpleNode jjtn012 = builder.openNode(JJTAUG_POWER);
                boolean jjtc012 = true;
                jjtree.openNodeScope(jjtn012);
                jjtreeOpenNodeScope(jjtn012);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case YIELD:
                            yield_expr();
                            break;
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[27] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                } catch (Throwable jjte012) {
                    if (jjtc012) {
                        jjtree.clearNodeScope(jjtn012);
                        jjtc012 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte012 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte012;
                        }
                    }
                    if (jjte012 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte012;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte012;
                    }
                } finally {
                    if (jjtc012) {
                        jjtree.closeNodeScope(jjtn012, 2);
                        jjtreeCloseNodeScope(jjtn012);
                    }
                }
                break;
            default:
                jj_la1[30] = jj_gen;
                SimpleNode jjtn013 = builder.openNode(JJTEXPR_STMT);
                boolean jjtc013 = true;
                jjtree.openNodeScope(jjtn013);
                jjtreeOpenNodeScope(jjtn013);
                try {
                    label_6: while (true) {
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case EQUAL:
                                ;
                                break;
                            default:
                                jj_la1[28] = jj_gen;
                                break label_6;
                        }
                        jj_consume_token(EQUAL);
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case YIELD:
                                yield_expr();
                                break;
                            case LPAREN:
                            case LBRACE:
                            case LBRACKET:
                            case PLUS:
                            case MINUS:
                            case NOT:
                            case NOT_BOOL:
                            case LAMBDA:
                            case AS:
                            case WITH:
                            case NAME:
                            case DECNUMBER:
                            case HEXNUMBER:
                            case OCTNUMBER:
                            case FLOAT:
                            case COMPLEX:
                            case SINGLE_STRING:
                            case SINGLE_STRING2:
                            case TRIPLE_STRING:
                            case TRIPLE_STRING2:
                            case SINGLE_USTRING:
                            case SINGLE_USTRING2:
                            case TRIPLE_USTRING:
                            case TRIPLE_USTRING2:
                            case 136:
                                SmartTestList();
                                break;
                            default:
                                jj_la1[29] = jj_gen;
                                jj_consume_token(-1);
                                throw new ParseException();
                        }
                    }
                } catch (Throwable jjte013) {
                    if (jjtc013) {
                        jjtree.clearNodeScope(jjtn013);
                        jjtc013 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte013 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte013;
                        }
                    }
                    if (jjte013 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte013;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte013;
                    }
                } finally {
                    if (jjtc013) {
                        jjtree.closeNodeScope(jjtn013, jjtree.nodeArity() + 1);
                        jjtreeCloseNodeScope(jjtn013);
                    }
                }
        }
    }

    //print_stmt: 'print' (test ',')* [test] | 'print' '>>' test (, test)+ [,]
    final public void print_stmt() throws ParseException {
        if (jj_2_9(2)) {
            jj_consume_token(PRINT);
            jj_consume_token(RSHIFT);
            SimpleNode jjtn001 = builder.openNode(JJTPRINTEXT_STMT);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                test();
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        label_7: while (true) {
                            grammarActions.findTokenAndAdd(",");
                            jj_consume_token(COMMA);
                            test();
                            if (jj_2_7(2)) {
                                ;
                            } else {
                                break label_7;
                            }
                        }
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case COMMA:
                                Comma();
                                break;
                            default:
                                jj_la1[31] = jj_gen;
                                ;
                        }
                        break;
                    default:
                        jj_la1[32] = jj_gen;
                        ;
                }
            } catch (Throwable jjte001) {
                if (jjtc001) {
                    jjtree.clearNodeScope(jjtn001);
                    jjtc001 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte001;
                    }
                }
                if (jjte001 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte001;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte001;
                }
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, true);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
        } else if (jj_2_10(2)) {
            jj_consume_token(PRINT);
            SimpleNode jjtn002 = builder.openNode(JJTPRINT_STMT);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002);
            jjtreeOpenNodeScope(jjtn002);
            try {
                test();
                label_8: while (true) {
                    if (jj_2_8(2)) {
                        ;
                    } else {
                        break label_8;
                    }
                    grammarActions.findTokenAndAdd(",");
                    jj_consume_token(COMMA);
                    test();
                }
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        Comma();
                        break;
                    default:
                        jj_la1[33] = jj_gen;
                        ;
                }
            } catch (Throwable jjte002) {
                if (jjtc002) {
                    jjtree.clearNodeScope(jjtn002);
                    jjtc002 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte002 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte002;
                    }
                }
                if (jjte002 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte002;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte002;
                }
            } finally {
                if (jjtc002) {
                    jjtree.closeNodeScope(jjtn002, true);
                    jjtreeCloseNodeScope(jjtn002);
                }
            }
        } else {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case PRINT:
                    SimpleNode jjtn003 = builder.openNode(JJTPRINT_STMT);
                    boolean jjtc003 = true;
                    jjtree.openNodeScope(jjtn003);
                    jjtreeOpenNodeScope(jjtn003);
                    try {
                        jj_consume_token(PRINT);
                    } finally {
                        if (jjtc003) {
                            jjtree.closeNodeScope(jjtn003, true);
                            jjtreeCloseNodeScope(jjtn003);
                        }
                    }
                    break;
                default:
                    jj_la1[34] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        }
    }

    //del_stmt: 'del' exprlist
    final public void del_stmt() throws ParseException {
        /*@bgen(jjtree) del_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTDEL_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            begin_del_stmt();
            exprlist();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_del_stmt() throws ParseException {
        /*@bgen(jjtree) begin_del_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_DEL_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = jj_consume_token(DEL);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            this.grammarActions.addToPeek(temporaryToken, false);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //pass_stmt: 'pass'
    final public Token pass_stmt() throws ParseException {
        /*@bgen(jjtree) pass_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTPASS_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token spStr;
        try {
            spStr = jj_consume_token(PASS);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            {
                if (true)
                    return spStr;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    //flow_stmt: break_stmt | continue_stmt | return_stmt | yield_stmt | raise_stmt
    final public void flow_stmt() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case BREAK:
                jj_consume_token(BREAK);
                SimpleNode jjtn001 = builder.openNode(JJTBREAK_STMT);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    jjtree.closeNodeScope(jjtn001, 0);
                    jjtc001 = false;
                    jjtreeCloseNodeScope(jjtn001);
                    grammarActions.addToPeek("break", true);
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, 0);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case CONTINUE:
                jj_consume_token(CONTINUE);
                SimpleNode jjtn002 = builder.openNode(JJTCONTINUE_STMT);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    jjtree.closeNodeScope(jjtn002, 0);
                    jjtc002 = false;
                    jjtreeCloseNodeScope(jjtn002);
                    grammarActions.addToPeek("continue", true);
                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, 0);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                break;
            case RETURN:
                return_stmt();
                break;
            case YIELD:
                yield_stmt();
                break;
            case RAISE:
                raise_stmt();
                break;
            default:
                jj_la1[35] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //return_stmt: 'return' [testlist]
    final public void return_stmt() throws ParseException {
        /*@bgen(jjtree) return_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTRETURN_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            begin_return_stmt();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case LBRACE:
                case LBRACKET:
                case PLUS:
                case MINUS:
                case NOT:
                case NOT_BOOL:
                case LAMBDA:
                case AS:
                case WITH:
                case NAME:
                case DECNUMBER:
                case HEXNUMBER:
                case OCTNUMBER:
                case FLOAT:
                case COMPLEX:
                case SINGLE_STRING:
                case SINGLE_STRING2:
                case TRIPLE_STRING:
                case TRIPLE_STRING2:
                case SINGLE_USTRING:
                case SINGLE_USTRING2:
                case TRIPLE_USTRING:
                case TRIPLE_USTRING2:
                case 136:
                    SmartTestList();
                    break;
                default:
                    jj_la1[36] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_return_stmt() throws ParseException {
        /*@bgen(jjtree) begin_return_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_RETURN_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(RETURN);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            this.grammarActions.addToPeek("return ", false);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //yield_stmt: yield_expr
    final public void yield_stmt() throws ParseException {
        /*@bgen(jjtree) yield_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTYIELD_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            yield_expr();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //yield_expr: 'yield' [testlist]
    final public void yield_expr() throws ParseException {
        /*@bgen(jjtree) yield_expr */
        SimpleNode jjtn000 = builder.openNode(JJTYIELD_EXPR);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token spStr;
        try {
            spStr = jj_consume_token(YIELD);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case LBRACE:
                case LBRACKET:
                case PLUS:
                case MINUS:
                case NOT:
                case NOT_BOOL:
                case LAMBDA:
                case AS:
                case WITH:
                case NAME:
                case DECNUMBER:
                case HEXNUMBER:
                case OCTNUMBER:
                case FLOAT:
                case COMPLEX:
                case SINGLE_STRING:
                case SINGLE_STRING2:
                case TRIPLE_STRING:
                case TRIPLE_STRING2:
                case SINGLE_USTRING:
                case SINGLE_USTRING2:
                case TRIPLE_USTRING:
                case TRIPLE_USTRING2:
                case 136:
                    SmartTestList();
                    break;
                default:
                    jj_la1[37] = jj_gen;
                    ;
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            this.grammarActions.addToPeek(spStr, false, Yield.class);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //raise_stmt: 'raise' [test [',' test [',' test]]]
    final public void raise_stmt() throws ParseException {
        /*@bgen(jjtree) raise_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTRAISE_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = grammarActions.createSpecialStr("raise");
            jj_consume_token(RAISE);
            grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case LBRACE:
                case LBRACKET:
                case PLUS:
                case MINUS:
                case NOT:
                case NOT_BOOL:
                case LAMBDA:
                case AS:
                case WITH:
                case NAME:
                case DECNUMBER:
                case HEXNUMBER:
                case OCTNUMBER:
                case FLOAT:
                case COMPLEX:
                case SINGLE_STRING:
                case SINGLE_STRING2:
                case TRIPLE_STRING:
                case TRIPLE_STRING2:
                case SINGLE_USTRING:
                case SINGLE_USTRING2:
                case TRIPLE_USTRING:
                case TRIPLE_USTRING2:
                case 136:
                    test();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COMMA:
                            grammarActions.findTokenAndAdd(",");
                            jj_consume_token(COMMA);
                            test();
                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                case COMMA:
                                    grammarActions.findTokenAndAdd(",");
                                    jj_consume_token(COMMA);
                                    test();
                                    break;
                                default:
                                    jj_la1[38] = jj_gen;
                                    ;
                            }
                            break;
                        default:
                            jj_la1[39] = jj_gen;
                            ;
                    }
                    break;
                default:
                    jj_la1[40] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //import_stmt: 'import' dotted_name (',' dotted_name)* | 'from' dotted_name 'import' ('*' | NAME (',' NAME)*)
    final public void import_stmt() throws ParseException {
        Import imp;
        Object spStr;
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case IMPORT:
                    spStr = jj_consume_token(IMPORT);
                    imp = Import();
                    if (imp != null) {
                        imp.addSpecial(spStr, false);
                    }
                    break;
                case FROM:
                    temporaryToken = grammarActions.createSpecialStr("from");
                    jj_consume_token(FROM);
                    grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
                    ImportFrom();
                    break;
                default:
                    jj_la1[41] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } catch (ParseException e) {
            handleErrorInImport(e);
        }
    }

    final public Import Import() throws ParseException {
        /*@bgen(jjtree) Import */
        SimpleNode jjtn000 = builder.openNode(JJTIMPORT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            dotted_as_name();
            label_9: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        ;
                        break;
                    default:
                        jj_la1[42] = jj_gen;
                        break label_9;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                dotted_as_name();
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            {
                if (true)
                    return (Import) jjtree.peekNode();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    //import_from: ('from' ('.'* dotted_name | '.'+)
    //              'import' ('*' | '(' import_as_names ')' | import_as_names))
    final public void ImportFrom() throws ParseException {
        /*@bgen(jjtree) ImportFrom */
        SimpleNode jjtn000 = builder.openNode(JJTIMPORTFROM);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        int level = 0;
        int state = 0;
        String fromName = null;
        String importName = null;
        try {
            label_10: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case DOT:
                        ;
                        break;
                    default:
                        jj_la1[43] = jj_gen;
                        break label_10;
                }
                jj_consume_token(DOT);
                level++;
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case AS:
                case WITH:
                case NAME:
                    fromName = dotted_name();
                    break;
                default:
                    jj_la1[44] = jj_gen;
                    ;
            }
            if (fromName == null && level == 0) {
                {
                    if (true)
                        throw new ParseException("Expecting to find '.' or name in import.");
                }
            }
            grammarActions.findTokenAndAdd("import");
            jj_consume_token(IMPORT);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case MULTIPLY:
                    jj_consume_token(MULTIPLY);
                    grammarActions.addSpecialToken("*", STRATEGY_ADD_AFTER_PREV);
                    break;
                case AS:
                case WITH:
                case NAME:
                    importName = import_as_name();
                    if (fromName != null && fromName.equals("__future__"))
                        handleFutureImports(importName);
                    label_11: while (true) {
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case COMMA:
                                ;
                                break;
                            default:
                                jj_la1[45] = jj_gen;
                                break label_11;
                        }
                        grammarActions.findTokenAndAdd(",");
                        jj_consume_token(COMMA);
                        importName = import_as_name();
                        if (fromName != null && fromName.equals("__future__"))
                            handleFutureImports(importName);
                    }
                    break;
                case LPAREN:
                    temporaryToken = grammarActions.createSpecialStr("(");
                    jj_consume_token(LPAREN);
                    grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
                    importName = import_as_name();
                    if (fromName != null && fromName.equals("__future__"))
                        handleFutureImports(importName);
                    label_12: while (true) {
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case COMMA:
                                ;
                                break;
                            default:
                                jj_la1[46] = jj_gen;
                                break label_12;
                        }
                        if (state != 0) {
                            {
                                if (true)
                                    throw new ParseException("Invalid syntax: 2 commas cannot be grouped.", getToken(1));
                            }
                        }
                        state = 1;
                        grammarActions.findTokenAndAdd(",");
                        jj_consume_token(COMMA);
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case AS:
                            case WITH:
                            case NAME:
                                state = 0;
                                importName = import_as_name();
                                if (fromName != null && fromName.equals("__future__"))
                                    handleFutureImports(importName);
                                break;
                            default:
                                jj_la1[47] = jj_gen;
                                ;
                        }
                    }
                    try {
                        grammarActions.findTokenAndAdd(")");
                        jj_consume_token(RPAREN);
                    } catch (ParseException e) {
                        handleRParensNearButNotCurrent(e);
                    }
                    break;
                default:
                    jj_la1[48] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            grammarActions.setImportFromLevel(level);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //dotted_as_name: dotted_name [NAME NAME]
    final public void dotted_as_name() throws ParseException {
        /*@bgen(jjtree) dotted_as_name */
        SimpleNode jjtn000 = builder.openNode(JJTDOTTED_AS_NAME);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            dotted_name();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case AS:
                    grammarActions.findTokenAndAdd("as");
                    jj_consume_token(AS);
                    Name();
                    break;
                default:
                    jj_la1[49] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //dotted_name: NAME ('.' NAME)*
    final public String dotted_name() throws ParseException {
        /*@bgen(jjtree) dotted_name */
        SimpleNode jjtn000 = builder.openNode(JJTDOTTED_NAME);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token t;
        FastStringBuffer sb = dottedNameStringBuffer.clear();
        try {
            t = Name();
            sb.append(t.image);
            label_13: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case DOT:
                        ;
                        break;
                    default:
                        jj_la1[50] = jj_gen;
                        break label_13;
                }
                jj_consume_token(DOT);
                t = Name2();
                sb.append(".").append(t.image);
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            {
                if (true)
                    return sb.toString();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    //import_as_name: NAME [NAME NAME]
    final public String import_as_name() throws ParseException {
        /*@bgen(jjtree) import_as_name */
        SimpleNode jjtn000 = builder.openNode(JJTIMPORT_AS_NAME);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token t;
        try {
            t = Name();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case AS:
                    grammarActions.findTokenAndAdd("as");
                    jj_consume_token(AS);
                    Name();
                    break;
                default:
                    jj_la1[51] = jj_gen;
                    ;
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            {
                if (true)
                    return t.image;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    //global_stmt: 'global' NAME (',' NAME)*
    final public void global_stmt() throws ParseException {
        /*@bgen(jjtree) global_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTGLOBAL_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = jj_consume_token(GLOBAL);
            grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            Name();
            label_14: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        ;
                        break;
                    default:
                        jj_la1[52] = jj_gen;
                        break label_14;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                Name();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //exec_stmt: 'exec' expr ['in' test [',' test]]
    final public void exec_stmt() throws ParseException {
        /*@bgen(jjtree) exec_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTEXEC_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = jj_consume_token(EXEC);
            grammarActions.addSpecialTokenToLastOpened(temporaryToken);
            expr();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case IN:
                    temporaryToken = jj_consume_token(IN);
                    grammarActions.addSpecialToken(temporaryToken);
                    test();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COMMA:
                            grammarActions.findTokenAndAdd(",");
                            jj_consume_token(COMMA);
                            test();
                            break;
                        default:
                            jj_la1[53] = jj_gen;
                            ;
                    }
                    break;
                default:
                    jj_la1[54] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //assert_stmt: 'assert' test [',' test]
    final public void assert_stmt() throws ParseException {
        /*@bgen(jjtree) assert_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTASSERT_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            test();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case COMMA:
                    grammarActions.findTokenAndAdd(",");
                    jj_consume_token(COMMA);
                    test();
                    break;
                default:
                    jj_la1[55] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef
    final public void compound_stmt() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case IF:
                if_stmt();
                break;
            case WHILE:
                while_stmt();
                break;
            case FOR:
                for_stmt();
                break;
            case TRY:
                try_stmt();
                break;
            case DEF:
            case AT:
                funcdef();
                break;
            case CLASS:
                classdef();
                break;
            default:
                jj_la1[56] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
    final public void if_stmt() throws ParseException {
        /*@bgen(jjtree) if_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTIF_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Object[] elseToks;
        try {
            temporaryToken = jj_consume_token(IF);
            this.markLastAsSuiteStart();
            grammarActions.addSpecialTokenToLastOpened(temporaryToken);
            test();
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
            label_15: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case ELIF:
                        ;
                        break;
                    default:
                        jj_la1[57] = jj_gen;
                        break label_15;
                }
                begin_elif_stmt();
                test();
                grammarActions.findTokenAndAdd(":");
                jj_consume_token(COLON);
                suite();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case ELSE:
                    elseToks = begin_else_stmt();
                    suite();
                    grammarActions.addToPeek(elseToks[0], false, Suite.class);
                    grammarActions.addToPeek(elseToks[1], false, Suite.class);
                    break;
                default:
                    jj_la1[58] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_elif_stmt() throws ParseException {
        /*@bgen(jjtree) begin_elif_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_ELIF_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(ELIF);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            this.grammarActions.addToPeek("elif", false);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //while_stmt: 'while' test ':' suite ['else' ':' suite]
    final public void while_stmt() throws ParseException {
        /*@bgen(jjtree) while_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTWHILE_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Object[] elseToks;
        try {
            begin_while_stmt();
            test();
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case ELSE:
                    elseToks = begin_else_stmt();
                    suite();
                    grammarActions.addToPeek(elseToks[0], false, Suite.class);
                    grammarActions.addToPeek(elseToks[1], false, Suite.class);
                    break;
                default:
                    jj_la1[59] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_while_stmt() throws ParseException {
        /*@bgen(jjtree) begin_while_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_WHILE_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = jj_consume_token(WHILE);
            grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            this.markLastAsSuiteStart();
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public Object[] begin_else_stmt() throws ParseException {
        /*@bgen(jjtree) begin_else_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_ELSE_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Object o1, o2;
        try {
            o1 = jj_consume_token(ELSE);
            o2 = jj_consume_token(COLON);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);
            {
                if (true)
                    return new Object[] { o1, o2 };
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    //for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
    final public void for_stmt() throws ParseException {
        /*@bgen(jjtree) for_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTFOR_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(FOR);
            this.markLastAsSuiteStart();
            grammarActions.addSpecialTokenToLastOpened("for ");
            exprlist();
            grammarActions.findTokenAndAdd("in");
            jj_consume_token(IN);
            SmartTestList();
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case ELSE:
                    begin_for_else_stmt();
                    suite();
                    break;
                default:
                    jj_la1[60] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_for_else_stmt() throws ParseException {
        /*@bgen(jjtree) begin_for_else_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_FOR_ELSE_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(ELSE);
            grammarActions.addSpecialToken("else", STRATEGY_BEFORE_NEXT);
            grammarActions.addSpecialToken(":", STRATEGY_BEFORE_NEXT);
            jj_consume_token(COLON);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //try_stmt: ('try' ':' suite (except_clause ':' suite)+ #diagram:break
    //           ['else' ':' suite] | 'try' ':' suite 'finally' ':' suite)
    final public void try_stmt() throws ParseException {
        SimpleNode tryNode;
        int i = 0;
        begin_try_stmt();
        tryNode = (SimpleNode) jjtree.peekNode();
        suite();
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case EXCEPT:
                label_16: while (true) {
                    except_clause(tryNode);
                    i++;
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case EXCEPT:
                            ;
                            break;
                        default:
                            jj_la1[61] = jj_gen;
                            break label_16;
                    }
                }
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case ELSE:
                        begin_try_else_stmt();
                        suite();
                        SimpleNode jjtn001 = builder.openNode(JJTTRYELSE_STMT);
                        boolean jjtc001 = true;
                        jjtree.openNodeScope(jjtn001);
                        jjtreeOpenNodeScope(jjtn001);
                        try {
                            jjtree.closeNodeScope(jjtn001, 2);
                            jjtc001 = false;
                            jjtreeCloseNodeScope(jjtn001);
                            i++;
                        } finally {
                            if (jjtc001) {
                                jjtree.closeNodeScope(jjtn001, 2);
                                jjtreeCloseNodeScope(jjtn001);
                            }
                        }
                        break;
                    default:
                        jj_la1[62] = jj_gen;
                        ;
                }
                SimpleNode jjtn003 = builder.openNode(JJTTRY_STMT);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
                jjtreeOpenNodeScope(jjtn003);
                try {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case FINALLY:
                            begin_finally_stmt();
                            suite();
                            SimpleNode jjtn002 = builder.openNode(JJTTRYFINALLY_OUTER_STMT);
                            boolean jjtc002 = true;
                            jjtree.openNodeScope(jjtn002);
                            jjtreeOpenNodeScope(jjtn002);
                            try {
                                jjtree.closeNodeScope(jjtn002, 2);
                                jjtc002 = false;
                                jjtreeCloseNodeScope(jjtn002);
                                i++;
                            } finally {
                                if (jjtc002) {
                                    jjtree.closeNodeScope(jjtn002, 2);
                                    jjtreeCloseNodeScope(jjtn002);
                                }
                            }
                            break;
                        default:
                            jj_la1[63] = jj_gen;
                            ;
                    }
                } catch (Throwable jjte003) {
                    if (jjtc003) {
                        jjtree.clearNodeScope(jjtn003);
                        jjtc003 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte003 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte003;
                        }
                    }
                    if (jjte003 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte003;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte003;
                    }
                } finally {
                    if (jjtc003) {
                        jjtree.closeNodeScope(jjtn003, i);
                        jjtreeCloseNodeScope(jjtn003);
                    }
                }
                break;
            case FINALLY:
                begin_finally_stmt();
                SimpleNode jjtn004 = builder.openNode(JJTTRYFINALLY_STMT);
                boolean jjtc004 = true;
                jjtree.openNodeScope(jjtn004);
                jjtreeOpenNodeScope(jjtn004);
                try {
                    suite();
                } catch (Throwable jjte004) {
                    if (jjtc004) {
                        jjtree.clearNodeScope(jjtn004);
                        jjtc004 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte004 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte004;
                        }
                    }
                    if (jjte004 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte004;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte004;
                    }
                } finally {
                    if (jjtc004) {
                        jjtree.closeNodeScope(jjtn004, jjtree.nodeArity() + 1);
                        jjtreeCloseNodeScope(jjtn004);
                    }
                }
                break;
            default:
                jj_la1[64] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //this is the 'try' ':'  it is needed because we need that scope closing for getting the specials.
    final public void begin_try_stmt() throws ParseException {
        /*@bgen(jjtree) begin_try_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_TRY_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(TRY);
            this.markLastAsSuiteStart();
            grammarActions.addSpecialToken("try", STRATEGY_BEFORE_NEXT);
            grammarActions.addSpecialToken(":", STRATEGY_BEFORE_NEXT);
            jj_consume_token(COLON);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_try_else_stmt() throws ParseException {
        /*@bgen(jjtree) begin_try_else_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_TRY_ELSE_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(ELSE);
            grammarActions.addSpecialToken("else", STRATEGY_BEFORE_NEXT);
            grammarActions.addSpecialToken(":", STRATEGY_BEFORE_NEXT);
            jj_consume_token(COLON);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_finally_stmt() throws ParseException {
        /*@bgen(jjtree) begin_finally_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_FINALLY_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(FINALLY);
            grammarActions.addSpecialToken("finally", STRATEGY_BEFORE_NEXT);
            grammarActions.addSpecialToken(":", STRATEGY_BEFORE_NEXT);
            jj_consume_token(COLON);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //except_clause: 'except' [test [',' test]]
    final public void except_clause(SimpleNode tryNode) throws ParseException {
        /*@bgen(jjtree) except_clause */
        SimpleNode jjtn000 = builder.openNode(JJTEXCEPT_CLAUSE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            begin_except_clause();
            this.grammarActions.addToPeek("except", false);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case LBRACE:
                case LBRACKET:
                case PLUS:
                case MINUS:
                case NOT:
                case NOT_BOOL:
                case LAMBDA:
                case AS:
                case WITH:
                case NAME:
                case DECNUMBER:
                case HEXNUMBER:
                case OCTNUMBER:
                case FLOAT:
                case COMPLEX:
                case SINGLE_STRING:
                case SINGLE_STRING2:
                case TRIPLE_STRING:
                case TRIPLE_STRING2:
                case SINGLE_USTRING:
                case SINGLE_USTRING2:
                case TRIPLE_USTRING:
                case TRIPLE_USTRING2:
                case 136:
                    test();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COMMA:
                            grammarActions.findTokenAndAdd(",");
                            jj_consume_token(COMMA);
                            test();
                            break;
                        default:
                            jj_la1[65] = jj_gen;
                            ;
                    }
                    break;
                default:
                    jj_la1[66] = jj_gen;
                    ;
            }
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void begin_except_clause() throws ParseException {
        /*@bgen(jjtree) begin_except_clause */
        SimpleNode jjtn000 = builder.openNode(JJTBEGIN_EXCEPT_CLAUSE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(EXCEPT);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //with_stmt: 'with' test [ with_var ] ':' suite
    final public void with_stmt() throws ParseException {
        /*@bgen(jjtree) with_stmt */
        SimpleNode jjtn000 = builder.openNode(JJTWITH_STMT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(WITH);
            grammarActions.addSpecialToken("with ", STRATEGY_BEFORE_NEXT);
            test();
            if (!acceptWithStmt) {
                if (true)
                    throw new ParseException(
                            "'from __future__ import with_statement' must be specified to accept 'with' statement.",
                            jjtree.peekNode());
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case AS:
                    with_var();
                    break;
                default:
                    jj_la1[67] = jj_gen;
                    ;
            }
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //with_var: 'as' expr
    final public void with_var() throws ParseException {
        /*@bgen(jjtree) with_var */
        SimpleNode jjtn000 = builder.openNode(JJTWITH_VAR);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = grammarActions.createSpecialStr("as");
            jj_consume_token(AS);
            grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            expr();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
    final public void suite() throws ParseException {
        /*@bgen(jjtree) suite */
        SimpleNode jjtn000 = builder.openNode(JJTSUITE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            try {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case LPAREN:
                    case LBRACE:
                    case LBRACKET:
                    case PLUS:
                    case MINUS:
                    case NOT:
                    case NOT_BOOL:
                    case LAMBDA:
                    case PRINT:
                    case PASS:
                    case BREAK:
                    case CONTINUE:
                    case RETURN:
                    case YIELD:
                    case IMPORT:
                    case FROM:
                    case DEL:
                    case RAISE:
                    case GLOBAL:
                    case EXEC:
                    case ASSERT:
                    case AS:
                    case WITH:
                    case NAME:
                    case DECNUMBER:
                    case HEXNUMBER:
                    case OCTNUMBER:
                    case FLOAT:
                    case COMPLEX:
                    case SINGLE_STRING:
                    case SINGLE_STRING2:
                    case TRIPLE_STRING:
                    case TRIPLE_STRING2:
                    case SINGLE_USTRING:
                    case SINGLE_USTRING2:
                    case TRIPLE_USTRING:
                    case TRIPLE_USTRING2:
                    case 136:
                        simple_stmt();
                        break;
                    case NEWLINE:
                        try {
                            try {
                                jj_consume_token(NEWLINE);
                            } catch (ParseException e) {
                                handleNoNewline(e);
                            }
                            jj_consume_token(INDENT);
                        } catch (ParseException e) {
                            handleErrorInIndent(e);
                        }
                        label_17: while (true) {
                            try {
                                stmt();
                            } catch (ParseException e) {
                                handleErrorInStmt(e);
                            }
                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                case LPAREN:
                                case LBRACE:
                                case LBRACKET:
                                case PLUS:
                                case MINUS:
                                case NOT:
                                case NOT_BOOL:
                                case LAMBDA:
                                case IF:
                                case WHILE:
                                case FOR:
                                case TRY:
                                case DEF:
                                case CLASS:
                                case PRINT:
                                case PASS:
                                case BREAK:
                                case CONTINUE:
                                case RETURN:
                                case YIELD:
                                case IMPORT:
                                case FROM:
                                case DEL:
                                case RAISE:
                                case GLOBAL:
                                case EXEC:
                                case ASSERT:
                                case AS:
                                case WITH:
                                case AT:
                                case NAME:
                                case DECNUMBER:
                                case HEXNUMBER:
                                case OCTNUMBER:
                                case FLOAT:
                                case COMPLEX:
                                case SINGLE_STRING:
                                case SINGLE_STRING2:
                                case TRIPLE_STRING:
                                case TRIPLE_STRING2:
                                case SINGLE_USTRING:
                                case SINGLE_USTRING2:
                                case TRIPLE_USTRING:
                                case TRIPLE_USTRING2:
                                case 136:
                                    ;
                                    break;
                                default:
                                    jj_la1[68] = jj_gen;
                                    break label_17;
                            }
                        }
                        try {
                            jj_consume_token(DEDENT);
                        } catch (ParseException e) {
                            handleErrorInDedent(e);
                        }
                        break;
                    case INDENT:
                        jj_consume_token(INDENT);
                        handleNoNewlineInSuiteFound();
                        label_18: while (true) {
                            try {
                                stmt();
                            } catch (ParseException e) {
                                handleErrorInStmt(e);
                            }
                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                case LPAREN:
                                case LBRACE:
                                case LBRACKET:
                                case PLUS:
                                case MINUS:
                                case NOT:
                                case NOT_BOOL:
                                case LAMBDA:
                                case IF:
                                case WHILE:
                                case FOR:
                                case TRY:
                                case DEF:
                                case CLASS:
                                case PRINT:
                                case PASS:
                                case BREAK:
                                case CONTINUE:
                                case RETURN:
                                case YIELD:
                                case IMPORT:
                                case FROM:
                                case DEL:
                                case RAISE:
                                case GLOBAL:
                                case EXEC:
                                case ASSERT:
                                case AS:
                                case WITH:
                                case AT:
                                case NAME:
                                case DECNUMBER:
                                case HEXNUMBER:
                                case OCTNUMBER:
                                case FLOAT:
                                case COMPLEX:
                                case SINGLE_STRING:
                                case SINGLE_STRING2:
                                case TRIPLE_STRING:
                                case TRIPLE_STRING2:
                                case SINGLE_USTRING:
                                case SINGLE_USTRING2:
                                case TRIPLE_USTRING:
                                case TRIPLE_USTRING2:
                                case 136:
                                    ;
                                    break;
                                default:
                                    jj_la1[69] = jj_gen;
                                    break label_18;
                            }
                        }
                        try {
                            jj_consume_token(DEDENT);
                        } catch (ParseException e) {
                            handleErrorInDedent(e);
                        }
                        break;
                    default:
                        jj_la1[70] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            } catch (ParseException e) {
                handleNoSuiteMatch(e);
            } catch (EmptySuiteException e) {

            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //Backward compatibility cruft to support:
    //[ x for x in lambda: True, lambda: False if x() ]
    //even while also allowing:
    //lambda x: 5 if x else 2
    //(But not a mix of the two)
    //
    //testlist_safe: old_test [(',' old_test)+ [',']]
    final public void testlist_safe() throws ParseException {
        old_test();
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case COMMA:
                label_19: while (true) {
                    grammarActions.addSpecialToken(",");
                    jj_consume_token(COMMA);
                    old_test();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COMMA:
                            ;
                            break;
                        default:
                            jj_la1[71] = jj_gen;
                            break label_19;
                    }
                }
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        grammarActions.addSpecialToken(",");
                        jj_consume_token(COMMA);
                        break;
                    default:
                        jj_la1[72] = jj_gen;
                        ;
                }
                break;
            default:
                jj_la1[73] = jj_gen;
                ;
        }
    }

    //old_test: or_test | old_lambdef
    final public void old_test() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case NOT_BOOL:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                or_test();
                break;
            case LAMBDA:
                old_lambdef();
                break;
            default:
                jj_la1[74] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //old_lambdef: 'lambda' [varargslist] ':' old_test
    final public void old_lambdef() throws ParseException {
        /*@bgen(jjtree) old_lambdef */
        SimpleNode jjtn000 = builder.openNode(JJTOLD_LAMBDEF);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        boolean hasArgs = false;
        try {
            jj_consume_token(LAMBDA);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case MULTIPLY:
                case POWER:
                case AS:
                case WITH:
                case NAME:
                    varargslist();
                    hasArgs = true;
                    break;
                default:
                    jj_la1[75] = jj_gen;
                    ;
            }
            temporaryToken = grammarActions.createSpecialStr(":");
            jj_consume_token(COLON);
            if (hasArgs)
                grammarActions.addSpecialToken(temporaryToken);
            else
                grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            old_test();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //test: or_test ['if' or_test 'else' test] | lambdef
    final public void test() throws ParseException {
        /*@bgen(jjtree) test */
        SimpleNode jjtn000 = builder.openNode(JJTTEST);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LAMBDA:
                    lambdef();
                    break;
                case LPAREN:
                case LBRACE:
                case LBRACKET:
                case PLUS:
                case MINUS:
                case NOT:
                case NOT_BOOL:
                case AS:
                case WITH:
                case NAME:
                case DECNUMBER:
                case HEXNUMBER:
                case OCTNUMBER:
                case FLOAT:
                case COMPLEX:
                case SINGLE_STRING:
                case SINGLE_STRING2:
                case TRIPLE_STRING:
                case TRIPLE_STRING2:
                case SINGLE_USTRING:
                case SINGLE_USTRING2:
                case TRIPLE_USTRING:
                case TRIPLE_USTRING2:
                case 136:
                    or_test();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case IF:
                            if_exp();
                            break;
                        default:
                            jj_la1[76] = jj_gen;
                            ;
                    }
                    break;
                default:
                    jj_la1[77] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void if_exp() throws ParseException {
        /*@bgen(jjtree) if_exp */
        SimpleNode jjtn000 = builder.openNode(JJTIF_EXP);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            temporaryToken = grammarActions.createSpecialStr("if");
            jj_consume_token(IF);
            grammarActions.addSpecialToken(temporaryToken, STRATEGY_ADD_AFTER_PREV);
            or_test();
            grammarActions.findTokenAndAdd("else");
            jj_consume_token(ELSE);
            test();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //or_test: or_test: and_test ('or' and_test)*
    final public void or_test() throws ParseException {
        /*@bgen(jjtree) #or_boolean(> 1) */
        SimpleNode jjtn000 = builder.openNode(JJTOR_BOOLEAN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            and_test();
            label_20: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case OR_BOOL:
                        ;
                        break;
                    default:
                        jj_la1[78] = jj_gen;
                        break label_20;
                }
                jj_consume_token(OR_BOOL);
                and_test();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //and_test: not_test ('and' not_test)*
    final public void and_test() throws ParseException {
        /*@bgen(jjtree) #and_boolean(> 1) */
        SimpleNode jjtn000 = builder.openNode(JJTAND_BOOLEAN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            not_test();
            label_21: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case AND_BOOL:
                        ;
                        break;
                    default:
                        jj_la1[79] = jj_gen;
                        break label_21;
                }
                jj_consume_token(AND_BOOL);
                not_test();
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //not_test: 'not' not_test | comparison
    final public void not_test() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case NOT_BOOL:
                jj_consume_token(NOT_BOOL);
                SimpleNode jjtn001 = builder.openNode(JJTNOT_1OP);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    not_test();
                } catch (Throwable jjte001) {
                    if (jjtc001) {
                        jjtree.clearNodeScope(jjtn001);
                        jjtc001 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte001 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte001;
                        }
                    }
                    if (jjte001 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte001;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte001;
                    }
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, 1);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                comparison();
                break;
            default:
                jj_la1[80] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //comparison: expr (comp_op expr)*
    final public void comparison() throws ParseException {
        SimpleNode jjtn001 = builder.openNode(JJTCOMPARISION);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        jjtreeOpenNodeScope(jjtn001);
        try {
            expr();
            label_22: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case GREATER:
                    case LESS:
                    case EQEQUAL:
                    case EQLESS:
                    case EQGREATER:
                    case LESSGREATER:
                    case NOTEQUAL:
                    case NOT_BOOL:
                    case IS:
                    case IN:
                        ;
                        break;
                    default:
                        jj_la1[81] = jj_gen;
                        break label_22;
                }
                comp_op();
                expr();
            }
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 2);
                jjtreeCloseNodeScope(jjtn001);
            }
        }
    }

    //comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
    final public void comp_op() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LESS:
                SimpleNode jjtn001 = builder.openNode(JJTLESS_CMP);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    jj_consume_token(LESS);
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, 0);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case GREATER:
                SimpleNode jjtn002 = builder.openNode(JJTGREATER_CMP);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    jj_consume_token(GREATER);
                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, 0);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                break;
            case EQEQUAL:
                SimpleNode jjtn003 = builder.openNode(JJTEQUAL_CMP);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
                jjtreeOpenNodeScope(jjtn003);
                try {
                    jj_consume_token(EQEQUAL);
                } finally {
                    if (jjtc003) {
                        jjtree.closeNodeScope(jjtn003, 0);
                        jjtreeCloseNodeScope(jjtn003);
                    }
                }
                break;
            case EQGREATER:
                SimpleNode jjtn004 = builder.openNode(JJTGREATER_EQUAL_CMP);
                boolean jjtc004 = true;
                jjtree.openNodeScope(jjtn004);
                jjtreeOpenNodeScope(jjtn004);
                try {
                    jj_consume_token(EQGREATER);
                } finally {
                    if (jjtc004) {
                        jjtree.closeNodeScope(jjtn004, 0);
                        jjtreeCloseNodeScope(jjtn004);
                    }
                }
                break;
            case EQLESS:
                SimpleNode jjtn005 = builder.openNode(JJTLESS_EQUAL_CMP);
                boolean jjtc005 = true;
                jjtree.openNodeScope(jjtn005);
                jjtreeOpenNodeScope(jjtn005);
                try {
                    jj_consume_token(EQLESS);
                } finally {
                    if (jjtc005) {
                        jjtree.closeNodeScope(jjtn005, 0);
                        jjtreeCloseNodeScope(jjtn005);
                    }
                }
                break;
            case LESSGREATER:
                SimpleNode jjtn006 = builder.openNode(JJTNOTEQUAL_CMP);
                boolean jjtc006 = true;
                jjtree.openNodeScope(jjtn006);
                jjtreeOpenNodeScope(jjtn006);
                try {
                    jj_consume_token(LESSGREATER);
                } finally {
                    if (jjtc006) {
                        jjtree.closeNodeScope(jjtn006, 0);
                        jjtreeCloseNodeScope(jjtn006);
                    }
                }
                break;
            case NOTEQUAL:
                SimpleNode jjtn007 = builder.openNode(JJTNOTEQUAL_CMP);
                boolean jjtc007 = true;
                jjtree.openNodeScope(jjtn007);
                jjtreeOpenNodeScope(jjtn007);
                try {
                    jj_consume_token(NOTEQUAL);
                } finally {
                    if (jjtc007) {
                        jjtree.closeNodeScope(jjtn007, 0);
                        jjtreeCloseNodeScope(jjtn007);
                    }
                }
                break;
            case IN:
                SimpleNode jjtn008 = builder.openNode(JJTIN_CMP);
                boolean jjtc008 = true;
                jjtree.openNodeScope(jjtn008);
                jjtreeOpenNodeScope(jjtn008);
                try {
                    jj_consume_token(IN);
                } finally {
                    if (jjtc008) {
                        jjtree.closeNodeScope(jjtn008, 0);
                        jjtreeCloseNodeScope(jjtn008);
                    }
                }
                break;
            case NOT_BOOL:
                jj_consume_token(NOT_BOOL);
                SimpleNode jjtn009 = builder.openNode(JJTNOT_IN_CMP);
                boolean jjtc009 = true;
                jjtree.openNodeScope(jjtn009);
                jjtreeOpenNodeScope(jjtn009);
                try {
                    jj_consume_token(IN);
                } finally {
                    if (jjtc009) {
                        jjtree.closeNodeScope(jjtn009, 0);
                        jjtreeCloseNodeScope(jjtn009);
                    }
                }
                break;
            default:
                jj_la1[82] = jj_gen;
                if (jj_2_11(2)) {
                    jj_consume_token(IS);
                    SimpleNode jjtn010 = builder.openNode(JJTIS_NOT_CMP);
                    boolean jjtc010 = true;
                    jjtree.openNodeScope(jjtn010);
                    jjtreeOpenNodeScope(jjtn010);
                    try {
                        jj_consume_token(NOT_BOOL);
                    } finally {
                        if (jjtc010) {
                            jjtree.closeNodeScope(jjtn010, 0);
                            jjtreeCloseNodeScope(jjtn010);
                        }
                    }
                } else {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case IS:
                            SimpleNode jjtn011 = builder.openNode(JJTIS_CMP);
                            boolean jjtc011 = true;
                            jjtree.openNodeScope(jjtn011);
                            jjtreeOpenNodeScope(jjtn011);
                            try {
                                jj_consume_token(IS);
                            } finally {
                                if (jjtc011) {
                                    jjtree.closeNodeScope(jjtn011, 0);
                                    jjtreeCloseNodeScope(jjtn011);
                                }
                            }
                            break;
                        default:
                            jj_la1[83] = jj_gen;
                            jj_consume_token(-1);
                            throw new ParseException();
                    }
                }
        }
    }

    //expr: xor_expr ('|' xor_expr)*
    final public void expr() throws ParseException {
        xor_expr();
        label_23: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case OR:
                    ;
                    break;
                default:
                    jj_la1[84] = jj_gen;
                    break label_23;
            }
            jj_consume_token(OR);
            SimpleNode jjtn001 = builder.openNode(JJTOR_2OP);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                xor_expr();
            } catch (Throwable jjte001) {
                if (jjtc001) {
                    jjtree.clearNodeScope(jjtn001);
                    jjtc001 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte001;
                    }
                }
                if (jjte001 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte001;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte001;
                }
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, 2);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
        }
    }

    //xor_expr: and_expr ('^' and_expr)*
    final public void xor_expr() throws ParseException {
        and_expr();
        label_24: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case XOR:
                    ;
                    break;
                default:
                    jj_la1[85] = jj_gen;
                    break label_24;
            }
            jj_consume_token(XOR);
            SimpleNode jjtn001 = builder.openNode(JJTXOR_2OP);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                and_expr();
            } catch (Throwable jjte001) {
                if (jjtc001) {
                    jjtree.clearNodeScope(jjtn001);
                    jjtc001 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte001;
                    }
                }
                if (jjte001 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte001;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte001;
                }
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, 2);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
        }
    }

    //and_expr: shift_expr ('&' shift_expr)*
    final public void and_expr() throws ParseException {
        shift_expr();
        label_25: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case AND:
                    ;
                    break;
                default:
                    jj_la1[86] = jj_gen;
                    break label_25;
            }
            jj_consume_token(AND);
            SimpleNode jjtn001 = builder.openNode(JJTAND_2OP);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                shift_expr();
            } catch (Throwable jjte001) {
                if (jjtc001) {
                    jjtree.clearNodeScope(jjtn001);
                    jjtc001 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte001;
                    }
                }
                if (jjte001 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte001;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte001;
                }
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, 2);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
        }
    }

    //shift_expr: arith_expr (('<<'|'>>') arith_expr)*
    final public void shift_expr() throws ParseException {
        arith_expr();
        label_26: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LSHIFT:
                case RSHIFT:
                    ;
                    break;
                default:
                    jj_la1[87] = jj_gen;
                    break label_26;
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LSHIFT:
                    jj_consume_token(LSHIFT);
                    SimpleNode jjtn001 = builder.openNode(JJTLSHIFT_2OP);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
                    jjtreeOpenNodeScope(jjtn001);
                    try {
                        arith_expr();
                    } catch (Throwable jjte001) {
                        if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte001 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte001;
                            }
                        }
                        if (jjte001 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte001;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte001;
                        }
                    } finally {
                        if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001, 2);
                            jjtreeCloseNodeScope(jjtn001);
                        }
                    }
                    break;
                case RSHIFT:
                    jj_consume_token(RSHIFT);
                    SimpleNode jjtn002 = builder.openNode(JJTRSHIFT_2OP);
                    boolean jjtc002 = true;
                    jjtree.openNodeScope(jjtn002);
                    jjtreeOpenNodeScope(jjtn002);
                    try {
                        arith_expr();
                    } catch (Throwable jjte002) {
                        if (jjtc002) {
                            jjtree.clearNodeScope(jjtn002);
                            jjtc002 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte002 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte002;
                            }
                        }
                        if (jjte002 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte002;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte002;
                        }
                    } finally {
                        if (jjtc002) {
                            jjtree.closeNodeScope(jjtn002, 2);
                            jjtreeCloseNodeScope(jjtn002);
                        }
                    }
                    break;
                default:
                    jj_la1[88] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        }
    }

    //arith_expr: term (('+'|'-') term)*
    final public void arith_expr() throws ParseException {
        term();
        label_27: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case PLUS:
                case MINUS:
                    ;
                    break;
                default:
                    jj_la1[89] = jj_gen;
                    break label_27;
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case PLUS:
                    jj_consume_token(PLUS);
                    SimpleNode jjtn001 = builder.openNode(JJTADD_2OP);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
                    jjtreeOpenNodeScope(jjtn001);
                    try {
                        term();
                    } catch (Throwable jjte001) {
                        if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte001 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte001;
                            }
                        }
                        if (jjte001 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte001;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte001;
                        }
                    } finally {
                        if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001, 2);
                            jjtreeCloseNodeScope(jjtn001);
                        }
                    }
                    break;
                case MINUS:
                    jj_consume_token(MINUS);
                    SimpleNode jjtn002 = builder.openNode(JJTSUB_2OP);
                    boolean jjtc002 = true;
                    jjtree.openNodeScope(jjtn002);
                    jjtreeOpenNodeScope(jjtn002);
                    try {
                        term();
                    } catch (Throwable jjte002) {
                        if (jjtc002) {
                            jjtree.clearNodeScope(jjtn002);
                            jjtc002 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte002 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte002;
                            }
                        }
                        if (jjte002 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte002;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte002;
                        }
                    } finally {
                        if (jjtc002) {
                            jjtree.closeNodeScope(jjtn002, 2);
                            jjtreeCloseNodeScope(jjtn002);
                        }
                    }
                    break;
                default:
                    jj_la1[90] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        }
    }

    //term: factor (('*'|'/'|'%') factor)*
    final public void term() throws ParseException {
        factor();
        label_28: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case MULTIPLY:
                case DIVIDE:
                case FLOORDIVIDE:
                case MODULO:
                    ;
                    break;
                default:
                    jj_la1[91] = jj_gen;
                    break label_28;
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case MULTIPLY:
                    jj_consume_token(MULTIPLY);
                    SimpleNode jjtn001 = builder.openNode(JJTMUL_2OP);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
                    jjtreeOpenNodeScope(jjtn001);
                    try {
                        factor();
                    } catch (Throwable jjte001) {
                        if (jjtc001) {
                            jjtree.clearNodeScope(jjtn001);
                            jjtc001 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte001 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte001;
                            }
                        }
                        if (jjte001 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte001;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte001;
                        }
                    } finally {
                        if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001, 2);
                            jjtreeCloseNodeScope(jjtn001);
                        }
                    }
                    break;
                case DIVIDE:
                    jj_consume_token(DIVIDE);
                    SimpleNode jjtn002 = builder.openNode(JJTDIV_2OP);
                    boolean jjtc002 = true;
                    jjtree.openNodeScope(jjtn002);
                    jjtreeOpenNodeScope(jjtn002);
                    try {
                        factor();
                    } catch (Throwable jjte002) {
                        if (jjtc002) {
                            jjtree.clearNodeScope(jjtn002);
                            jjtc002 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte002 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte002;
                            }
                        }
                        if (jjte002 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte002;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte002;
                        }
                    } finally {
                        if (jjtc002) {
                            jjtree.closeNodeScope(jjtn002, 2);
                            jjtreeCloseNodeScope(jjtn002);
                        }
                    }
                    break;
                case FLOORDIVIDE:
                    jj_consume_token(FLOORDIVIDE);
                    SimpleNode jjtn003 = builder.openNode(JJTFLOORDIV_2OP);
                    boolean jjtc003 = true;
                    jjtree.openNodeScope(jjtn003);
                    jjtreeOpenNodeScope(jjtn003);
                    try {
                        factor();
                    } catch (Throwable jjte003) {
                        if (jjtc003) {
                            jjtree.clearNodeScope(jjtn003);
                            jjtc003 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte003 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte003;
                            }
                        }
                        if (jjte003 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte003;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte003;
                        }
                    } finally {
                        if (jjtc003) {
                            jjtree.closeNodeScope(jjtn003, 2);
                            jjtreeCloseNodeScope(jjtn003);
                        }
                    }
                    break;
                case MODULO:
                    jj_consume_token(MODULO);
                    SimpleNode jjtn004 = builder.openNode(JJTMOD_2OP);
                    boolean jjtc004 = true;
                    jjtree.openNodeScope(jjtn004);
                    jjtreeOpenNodeScope(jjtn004);
                    try {
                        factor();
                    } catch (Throwable jjte004) {
                        if (jjtc004) {
                            jjtree.clearNodeScope(jjtn004);
                            jjtc004 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte004 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte004;
                            }
                        }
                        if (jjte004 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte004;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte004;
                        }
                    } finally {
                        if (jjtc004) {
                            jjtree.closeNodeScope(jjtn004, 2);
                            jjtreeCloseNodeScope(jjtn004);
                        }
                    }
                    break;
                default:
                    jj_la1[92] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        }
    }

    //factor: ('+'|'-'|'~') factor | power
    final public void factor() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case PLUS:
                jj_consume_token(PLUS);
                SimpleNode jjtn001 = builder.openNode(JJTPOS_1OP);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    factor();
                } catch (Throwable jjte001) {
                    if (jjtc001) {
                        jjtree.clearNodeScope(jjtn001);
                        jjtc001 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte001 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte001;
                        }
                    }
                    if (jjte001 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte001;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte001;
                    }
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, 1);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case MINUS:
                jj_consume_token(MINUS);
                SimpleNode jjtn002 = builder.openNode(JJTNEG_1OP);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    factor();
                } catch (Throwable jjte002) {
                    if (jjtc002) {
                        jjtree.clearNodeScope(jjtn002);
                        jjtc002 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte002 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte002;
                        }
                    }
                    if (jjte002 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte002;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte002;
                    }
                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, 1);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                break;
            case NOT:
                jj_consume_token(NOT);
                SimpleNode jjtn003 = builder.openNode(JJTINVERT_1OP);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
                jjtreeOpenNodeScope(jjtn003);
                try {
                    factor();
                } catch (Throwable jjte003) {
                    if (jjtc003) {
                        jjtree.clearNodeScope(jjtn003);
                        jjtc003 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte003 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte003;
                        }
                    }
                    if (jjte003 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte003;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte003;
                    }
                } finally {
                    if (jjtc003) {
                        jjtree.closeNodeScope(jjtn003, 1);
                        jjtreeCloseNodeScope(jjtn003);
                    }
                }
                break;
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                power();
                break;
            default:
                jj_la1[93] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    /*Modified, no recursion*/

    //power: atom trailer* ('**' factor)*
    final public void power() throws ParseException {
        atomtrailer();
        label_29: while (true) {
            if (jj_2_12(2)) {
                ;
            } else {
                break label_29;
            }
            jj_consume_token(POWER);
            SimpleNode jjtn001 = builder.openNode(JJTPOW_2OP);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                factor();
            } catch (Throwable jjte001) {
                if (jjtc001) {
                    jjtree.clearNodeScope(jjtn001);
                    jjtc001 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte001;
                    }
                }
                if (jjte001 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte001;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte001;
                }
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, 2);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
        }
    }

    //trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
    final public void atomtrailer() throws ParseException {
        Object spStr;
        Object spStr2;
        atom();
        label_30: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case LBRACKET:
                case DOT:
                    ;
                    break;
                default:
                    jj_la1[94] = jj_gen;
                    break label_30;
            }
            if (jj_2_13(2)) {
                SimpleNode jjtn001 = builder.openNode(JJTCALL_OP);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    spStr = grammarActions.createSpecialStr("(", false);
                    jj_consume_token(LPAREN);
                    spStr2 = grammarActions.createSpecialStr(")", false);
                    jj_consume_token(RPAREN);
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, 1);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                grammarActions.addToPeekCallFunc(spStr, true);
                grammarActions.addToPeek(spStr2, true);
            } else if (jj_2_14(2)) {
                SimpleNode jjtn002 = builder.openNode(JJTCALL_OP);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    spStr = grammarActions.createSpecialStr("(", false);
                    jj_consume_token(LPAREN);
                    insidetuporcall();
                    spStr2 = grammarActions.createSpecialStr(")", false);
                    jj_consume_token(RPAREN);
                } catch (Throwable jjte002) {
                    if (jjtc002) {
                        jjtree.clearNodeScope(jjtn002);
                        jjtc002 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte002 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte002;
                        }
                    }
                    if (jjte002 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte002;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte002;
                    }
                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, jjtree.nodeArity() + 1);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                grammarActions.addToPeekCallFunc(spStr, true);
                grammarActions.addToPeek(spStr2, true);
            } else {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case LBRACKET:
                        spStr = grammarActions.createSpecialStr("[", false);
                        jj_consume_token(LBRACKET);
                        subscriptlist();
                        spStr2 = grammarActions.createSpecialStr("]", false);
                        SimpleNode jjtn003 = builder.openNode(JJTINDEX_OP);
                        boolean jjtc003 = true;
                        jjtree.openNodeScope(jjtn003);
                        jjtreeOpenNodeScope(jjtn003);
                        try {
                            jj_consume_token(RBRACKET);
                        } finally {
                            if (jjtc003) {
                                jjtree.closeNodeScope(jjtn003, 2);
                                jjtreeCloseNodeScope(jjtn003);
                            }
                        }
                        grammarActions.addToPeek(spStr, false);
                        grammarActions.addToPeek(spStr2, true);
                        break;
                    case DOT:
                        jj_consume_token(DOT);
                        SimpleNode jjtn004 = builder.openNode(JJTDOT_OP);
                        boolean jjtc004 = true;
                        jjtree.openNodeScope(jjtn004);
                        jjtreeOpenNodeScope(jjtn004);
                        try {
                            Name2();
                        } catch (Throwable jjte004) {
                            if (jjtc004) {
                                jjtree.clearNodeScope(jjtn004);
                                jjtc004 = false;
                            } else {
                                jjtree.popNode();
                            }
                            if (jjte004 instanceof RuntimeException) {
                                {
                                    if (true)
                                        throw (RuntimeException) jjte004;
                                }
                            }
                            if (jjte004 instanceof ParseException) {
                                {
                                    if (true)
                                        throw (ParseException) jjte004;
                                }
                            }
                            {
                                if (true)
                                    throw (Error) jjte004;
                            }
                        } finally {
                            if (jjtc004) {
                                jjtree.closeNodeScope(jjtn004, 2);
                                jjtreeCloseNodeScope(jjtn004);
                            }
                        }
                        break;
                    default:
                        jj_la1[95] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            }
        }
    }

    //atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
    final public void atom() throws ParseException {
        Object spStr;
        Object spStr2;
        if (jj_2_15(2)) {
            SimpleNode jjtn001 = builder.openNode(JJTTUPLE);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                spStr = grammarActions.createSpecialStr("(", false);
                jj_consume_token(LPAREN);
                spStr2 = grammarActions.createSpecialStr(")", false);
                jj_consume_token(RPAREN);
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, true);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
            grammarActions.addToPeek(spStr, false);
            grammarActions.addToPeek(spStr2, true);
        } else if (jj_2_16(2)) {
            SimpleNode jjtn002 = builder.openNode(JJTTUPLE);
            boolean jjtc002 = true;
            jjtree.openNodeScope(jjtn002);
            jjtreeOpenNodeScope(jjtn002);
            try {
                spStr = grammarActions.createSpecialStr("(", false);
                jj_consume_token(LPAREN);
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case YIELD:
                        yield_expr();
                        break;
                    default:
                        jj_la1[96] = jj_gen;
                        insidetuporcall();
                }
                spStr2 = grammarActions.createSpecialStr(")", false);
                jj_consume_token(RPAREN);
            } catch (Throwable jjte002) {
                if (jjtc002) {
                    jjtree.clearNodeScope(jjtn002);
                    jjtc002 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte002 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte002;
                    }
                }
                if (jjte002 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte002;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte002;
                }
            } finally {
                if (jjtc002) {
                    jjtree.closeNodeScope(jjtn002, true);
                    jjtreeCloseNodeScope(jjtn002);
                }
            }
            grammarActions.addToPeek(spStr, false);
            grammarActions.addToPeek(spStr2, true);
        } else {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                    jj_consume_token(LPAREN);
                    grammarActions.addSpecialToken("(", STRATEGY_BEFORE_NEXT);
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            SmartTestList();
                            break;
                        default:
                            jj_la1[97] = jj_gen;
                            ;
                    }
                    try {
                        grammarActions.findTokenAndAdd(")");
                        jj_consume_token(RPAREN);
                    } catch (ParseException e) {
                        handleRParensNearButNotCurrent(e);
                    }
                    break;
                case LBRACKET:
                    SimpleNode jjtn003 = builder.openNode(JJTLIST);
                    boolean jjtc003 = true;
                    jjtree.openNodeScope(jjtn003);
                    jjtreeOpenNodeScope(jjtn003);
                    try {
                        spStr = grammarActions.createSpecialStr("[", false);
                        jj_consume_token(LBRACKET);
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case LPAREN:
                            case LBRACE:
                            case LBRACKET:
                            case PLUS:
                            case MINUS:
                            case NOT:
                            case NOT_BOOL:
                            case LAMBDA:
                            case AS:
                            case WITH:
                            case NAME:
                            case DECNUMBER:
                            case HEXNUMBER:
                            case OCTNUMBER:
                            case FLOAT:
                            case COMPLEX:
                            case SINGLE_STRING:
                            case SINGLE_STRING2:
                            case TRIPLE_STRING:
                            case TRIPLE_STRING2:
                            case SINGLE_USTRING:
                            case SINGLE_USTRING2:
                            case TRIPLE_USTRING:
                            case TRIPLE_USTRING2:
                            case 136:
                                listmaker();
                                break;
                            default:
                                jj_la1[98] = jj_gen;
                                ;
                        }
                        spStr2 = grammarActions.createSpecialStr("]", false);
                        jj_consume_token(RBRACKET);
                    } catch (Throwable jjte003) {
                        if (jjtc003) {
                            jjtree.clearNodeScope(jjtn003);
                            jjtc003 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte003 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte003;
                            }
                        }
                        if (jjte003 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte003;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte003;
                        }
                    } finally {
                        if (jjtc003) {
                            jjtree.closeNodeScope(jjtn003, true);
                            jjtreeCloseNodeScope(jjtn003);
                        }
                    }
                    grammarActions.addToPeek(spStr, false);
                    grammarActions.addToPeek(spStr2, true);
                    break;
                case LBRACE:
                    SimpleNode jjtn004 = builder.openNode(JJTDICTIONARY);
                    boolean jjtc004 = true;
                    jjtree.openNodeScope(jjtn004);
                    jjtreeOpenNodeScope(jjtn004);
                    try {
                        spStr = grammarActions.createSpecialStr("{", false);
                        jj_consume_token(LBRACE);
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case LPAREN:
                            case LBRACE:
                            case LBRACKET:
                            case PLUS:
                            case MINUS:
                            case NOT:
                            case NOT_BOOL:
                            case LAMBDA:
                            case AS:
                            case WITH:
                            case NAME:
                            case DECNUMBER:
                            case HEXNUMBER:
                            case OCTNUMBER:
                            case FLOAT:
                            case COMPLEX:
                            case SINGLE_STRING:
                            case SINGLE_STRING2:
                            case TRIPLE_STRING:
                            case TRIPLE_STRING2:
                            case SINGLE_USTRING:
                            case SINGLE_USTRING2:
                            case TRIPLE_USTRING:
                            case TRIPLE_USTRING2:
                            case 136:
                                dictmaker();
                                break;
                            default:
                                jj_la1[99] = jj_gen;
                                ;
                        }
                        spStr2 = grammarActions.createSpecialStr("}", false);
                        jj_consume_token(RBRACE);
                    } catch (Throwable jjte004) {
                        if (jjtc004) {
                            jjtree.clearNodeScope(jjtn004);
                            jjtc004 = false;
                        } else {
                            jjtree.popNode();
                        }
                        if (jjte004 instanceof RuntimeException) {
                            {
                                if (true)
                                    throw (RuntimeException) jjte004;
                            }
                        }
                        if (jjte004 instanceof ParseException) {
                            {
                                if (true)
                                    throw (ParseException) jjte004;
                            }
                        }
                        {
                            if (true)
                                throw (Error) jjte004;
                        }
                    } finally {
                        if (jjtc004) {
                            jjtree.closeNodeScope(jjtn004, true);
                            jjtreeCloseNodeScope(jjtn004);
                        }
                    }
                    grammarActions.addToPeek(spStr, false);
                    grammarActions.addToPeek(spStr2, true);
                    break;
                case 136:
                    jj_consume_token(136);
                    SmartTestList();
                    SimpleNode jjtn005 = builder.openNode(JJTSTR_1OP);
                    boolean jjtc005 = true;
                    jjtree.openNodeScope(jjtn005);
                    jjtreeOpenNodeScope(jjtn005);
                    try {
                        jj_consume_token(136);
                    } finally {
                        if (jjtc005) {
                            jjtree.closeNodeScope(jjtn005, 1);
                            jjtreeCloseNodeScope(jjtn005);
                        }
                    }
                    break;
                case AS:
                case WITH:
                case NAME:
                    Name();
                    break;
                case DECNUMBER:
                case HEXNUMBER:
                case OCTNUMBER:
                case FLOAT:
                case COMPLEX:
                    Number();
                    break;
                case SINGLE_STRING:
                case SINGLE_STRING2:
                case TRIPLE_STRING:
                case TRIPLE_STRING2:
                case SINGLE_USTRING:
                case SINGLE_USTRING2:
                case TRIPLE_USTRING:
                case TRIPLE_USTRING2:
                    String();
                    label_31: while (true) {
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case SINGLE_STRING:
                            case SINGLE_STRING2:
                            case TRIPLE_STRING:
                            case TRIPLE_STRING2:
                            case SINGLE_USTRING:
                            case SINGLE_USTRING2:
                            case TRIPLE_USTRING:
                            case TRIPLE_USTRING2:
                                ;
                                break;
                            default:
                                jj_la1[100] = jj_gen;
                                break label_31;
                        }
                        SimpleNode jjtn006 = builder.openNode(JJTSTRJOIN);
                        boolean jjtc006 = true;
                        jjtree.openNodeScope(jjtn006);
                        jjtreeOpenNodeScope(jjtn006);
                        try {
                            String();
                        } catch (Throwable jjte006) {
                            if (jjtc006) {
                                jjtree.clearNodeScope(jjtn006);
                                jjtc006 = false;
                            } else {
                                jjtree.popNode();
                            }
                            if (jjte006 instanceof RuntimeException) {
                                {
                                    if (true)
                                        throw (RuntimeException) jjte006;
                                }
                            }
                            if (jjte006 instanceof ParseException) {
                                {
                                    if (true)
                                        throw (ParseException) jjte006;
                                }
                            }
                            {
                                if (true)
                                    throw (Error) jjte006;
                            }
                        } finally {
                            if (jjtc006) {
                                jjtree.closeNodeScope(jjtn006, 2);
                                jjtreeCloseNodeScope(jjtn006);
                            }
                        }
                    }
                    break;
                default:
                    jj_la1[101] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        }
    }

    //we can be inside a tuple or a call, and we may have list comprehension in it. (fabioz)
    final public void insidetuporcall() throws ParseException {
        arglist();
        label_32: while (true) {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case FOR:
                    ;
                    break;
                default:
                    jj_la1[102] = jj_gen;
                    break label_32;
            }
            list_for();
        }
    }

    //lambdef: 'lambda' [varargslist] ':' test
    //we add the colon to the args if there is some argument... otherwise, we add it to the first token that appears on the test
    final public void lambdef() throws ParseException {
        /*@bgen(jjtree) lambdef */
        SimpleNode jjtn000 = builder.openNode(JJTLAMBDEF);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        boolean hasArgs = false;
        try {
            jj_consume_token(LAMBDA);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                case MULTIPLY:
                case POWER:
                case AS:
                case WITH:
                case NAME:
                    varargslist();
                    hasArgs = true;
                    break;
                default:
                    jj_la1[103] = jj_gen;
                    ;
            }
            temporaryToken = grammarActions.createSpecialStr(":");
            jj_consume_token(COLON);
            if (hasArgs)
                grammarActions.addSpecialToken(temporaryToken);
            else
                grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
            test();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //subscriptlist: subscript (',' subscript)* [',']
    final public void subscriptlist() throws ParseException {
        SimpleNode jjtn001 = builder.openNode(JJTSUBSCRIPTLIST);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        jjtreeOpenNodeScope(jjtn001);
        try {
            subscript();
            label_33: while (true) {
                if (jj_2_17(2)) {
                    ;
                } else {
                    break label_33;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                subscript();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case COMMA:
                    Comma();
                    break;
                default:
                    jj_la1[104] = jj_gen;
                    ;
            }
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
                jjtreeCloseNodeScope(jjtn001);
            }
        }
    }

    //subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
    final public void subscript() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case DOT:
                jj_consume_token(DOT);
                jj_consume_token(DOT);
                SimpleNode jjtn001 = builder.openNode(JJTELLIPSIS);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    jj_consume_token(DOT);
                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, true);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case NOT_BOOL:
            case LAMBDA:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                SimpleNode jjtn002 = builder.openNode(JJTSLICE);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    test();
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COLON:
                            slice();
                            break;
                        default:
                            jj_la1[105] = jj_gen;
                            ;
                    }
                } catch (Throwable jjte002) {
                    if (jjtc002) {
                        jjtree.clearNodeScope(jjtn002);
                        jjtc002 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte002 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte002;
                        }
                    }
                    if (jjte002 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte002;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte002;
                    }
                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, true);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                break;
            case COLON:
                SimpleNode jjtn003 = builder.openNode(JJTSLICE);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
                jjtreeOpenNodeScope(jjtn003);
                try {
                    slice();
                } catch (Throwable jjte003) {
                    if (jjtc003) {
                        jjtree.clearNodeScope(jjtn003);
                        jjtc003 = false;
                    } else {
                        jjtree.popNode();
                    }
                    if (jjte003 instanceof RuntimeException) {
                        {
                            if (true)
                                throw (RuntimeException) jjte003;
                        }
                    }
                    if (jjte003 instanceof ParseException) {
                        {
                            if (true)
                                throw (ParseException) jjte003;
                        }
                    }
                    {
                        if (true)
                            throw (Error) jjte003;
                    }
                } finally {
                    if (jjtc003) {
                        jjtree.closeNodeScope(jjtn003, jjtree.nodeArity() > 0);
                        jjtreeCloseNodeScope(jjtn003);
                    }
                }
                break;
            default:
                jj_la1[106] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //sliceop: ':' [test]
    final public void slice() throws ParseException {
        Colon();
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case NOT_BOOL:
            case LAMBDA:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                test();
                break;
            default:
                jj_la1[107] = jj_gen;
                ;
        }
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case COLON:
                Colon();
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case LPAREN:
                    case LBRACE:
                    case LBRACKET:
                    case PLUS:
                    case MINUS:
                    case NOT:
                    case NOT_BOOL:
                    case LAMBDA:
                    case AS:
                    case WITH:
                    case NAME:
                    case DECNUMBER:
                    case HEXNUMBER:
                    case OCTNUMBER:
                    case FLOAT:
                    case COMPLEX:
                    case SINGLE_STRING:
                    case SINGLE_STRING2:
                    case TRIPLE_STRING:
                    case TRIPLE_STRING2:
                    case SINGLE_USTRING:
                    case SINGLE_USTRING2:
                    case TRIPLE_USTRING:
                    case TRIPLE_USTRING2:
                    case 136:
                        test();
                        break;
                    default:
                        jj_la1[108] = jj_gen;
                        ;
                }
                break;
            default:
                jj_la1[109] = jj_gen;
                ;
        }
    }

    final public void Colon() throws ParseException {
        /*@bgen(jjtree) Colon */
        SimpleNode jjtn000 = builder.openNode(JJTCOLON);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            grammarActions.addSpecialToken(grammarActions.createSpecialStr(":", false), STRATEGY_BEFORE_NEXT);
            jj_consume_token(COLON);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void Comma() throws ParseException {
        /*@bgen(jjtree) Comma */
        SimpleNode jjtn000 = builder.openNode(JJTCOMMA);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(COMMA);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //exprlist: expr (',' expr)* [',']
    final public void exprlist() throws ParseException {
        SimpleNode jjtn001 = builder.openNode(JJTTUPLE);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        jjtreeOpenNodeScope(jjtn001);
        try {
            expr();
            label_34: while (true) {
                if (jj_2_18(2)) {
                    ;
                } else {
                    break label_34;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                expr();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case COMMA:
                    Comma();
                    break;
                default:
                    jj_la1[110] = jj_gen;
                    ;
            }
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
                jjtreeCloseNodeScope(jjtn001);
            }
        }
    }

    //testlist: test (',' test)* [',']
    final public void SmartTestList() throws ParseException {
        SimpleNode jjtn001 = builder.openNode(JJTTUPLE);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        jjtreeOpenNodeScope(jjtn001);
        try {
            test();
            label_35: while (true) {
                if (jj_2_19(2)) {
                    ;
                } else {
                    break label_35;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                test();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case COMMA:
                    Comma();
                    break;
                default:
                    jj_la1[111] = jj_gen;
                    ;
            }
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
                jjtreeCloseNodeScope(jjtn001);
            }
        }
    }

    //testlist: test (',' test)* [',']
    final public void testlist() throws ParseException {
        test();
        label_36: while (true) {
            if (jj_2_20(2)) {
                ;
            } else {
                break label_36;
            }
            grammarActions.findTokenAndAdd(",");
            jj_consume_token(COMMA);
            test();
        }
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case COMMA:
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                break;
            default:
                jj_la1[112] = jj_gen;
                ;
        }
    }

    //dictmaker: test ':' test (',' test ':' test)* [',']
    final public void dictmaker() throws ParseException {
        test();
        grammarActions.findTokenAndAdd(":");
        jj_consume_token(COLON);
        try {
            test();
        } catch (ParseException e) {
            handleNoValInDict(e);
        }
        label_37: while (true) {
            if (jj_2_21(2)) {
                ;
            } else {
                break label_37;
            }
            grammarActions.findTokenAndAdd(",");
            jj_consume_token(COMMA);
            test();
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            test();
        }
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case COMMA:
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                break;
            default:
                jj_la1[113] = jj_gen;
                ;
        }
    }

    //listmaker: test ( list_for | (',' test)* [','] )
    final public void listmaker() throws ParseException {
        test();
        if (jj_2_23(2)) {
            label_38: while (true) {
                list_for();
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case FOR:
                        ;
                        break;
                    default:
                        jj_la1[114] = jj_gen;
                        break label_38;
                }
            }
        } else {
            label_39: while (true) {
                if (jj_2_22(2)) {
                    ;
                } else {
                    break label_39;
                }
                grammarActions.findTokenAndAdd(",");
                jj_consume_token(COMMA);
                test();
            }
            SimpleNode jjtn001 = builder.openNode(JJTTUPLE);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
            jjtreeOpenNodeScope(jjtn001);
            try {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        Comma();
                        break;
                    default:
                        jj_la1[115] = jj_gen;
                        ;
                }
            } catch (Throwable jjte001) {
                if (jjtc001) {
                    jjtree.clearNodeScope(jjtn001);
                    jjtc001 = false;
                } else {
                    jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                    {
                        if (true)
                            throw (RuntimeException) jjte001;
                    }
                }
                if (jjte001 instanceof ParseException) {
                    {
                        if (true)
                            throw (ParseException) jjte001;
                    }
                }
                {
                    if (true)
                        throw (Error) jjte001;
                }
            } finally {
                if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
                    jjtreeCloseNodeScope(jjtn001);
                }
            }
        }
    }

    //list_iter: [list_for | list_if]
    final public void list_iter() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case FOR:
                list_for();
                break;
            case IF:
                list_if();
                break;
            default:
                jj_la1[116] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    //list_for: 'for' exprlist 'in' testlist list_iter
    final public void list_for() throws ParseException {
        /*@bgen(jjtree) list_for */
        SimpleNode jjtn000 = builder.openNode(JJTLIST_FOR);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            grammarActions.findTokenAndAdd("for");
            jj_consume_token(FOR);
            exprlist();
            grammarActions.findTokenAndAdd("in");
            jj_consume_token(IN);
            testlist_safe();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case IF:
                case FOR:
                    list_iter();
                    break;
                default:
                    jj_la1[117] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void list_if() throws ParseException {
        grammarActions.findTokenAndAdd("if");
        jj_consume_token(IF);
        old_test();
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case IF:
            case FOR:
                list_iter();
                break;
            default:
                jj_la1[118] = jj_gen;
                ;
        }
    }

    //classdef: 'class' NAME ['(' [testlist] ')'] ':' suite
    final public void classdef() throws ParseException {
        /*@bgen(jjtree) classdef */
        SimpleNode jjtn000 = builder.openNode(JJTCLASSDEF);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(CLASS);
            this.markLastAsSuiteStart();
            Name();
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case LPAREN:
                    temporaryToken = grammarActions.createSpecialStr("(");
                    jj_consume_token(LPAREN);
                    grammarActions.addSpecialToken(temporaryToken, STRATEGY_BEFORE_NEXT);
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case LPAREN:
                        case LBRACE:
                        case LBRACKET:
                        case PLUS:
                        case MINUS:
                        case NOT:
                        case NOT_BOOL:
                        case LAMBDA:
                        case AS:
                        case WITH:
                        case NAME:
                        case DECNUMBER:
                        case HEXNUMBER:
                        case OCTNUMBER:
                        case FLOAT:
                        case COMPLEX:
                        case SINGLE_STRING:
                        case SINGLE_STRING2:
                        case TRIPLE_STRING:
                        case TRIPLE_STRING2:
                        case SINGLE_USTRING:
                        case SINGLE_USTRING2:
                        case TRIPLE_USTRING:
                        case TRIPLE_USTRING2:
                        case 136:
                            testlist();
                            break;
                        default:
                            jj_la1[119] = jj_gen;
                            ;
                    }
                    try {
                        grammarActions.findTokenAndAdd(")");
                        jj_consume_token(RPAREN);
                    } catch (ParseException e) {
                        handleRParensNearButNotCurrent(e);
                    }
                    break;
                default:
                    jj_la1[120] = jj_gen;
                    ;
            }
            grammarActions.findTokenAndAdd(":");
            jj_consume_token(COLON);
            suite();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //arglist: (argument ',')*
    //              (argument [',']| '*' test [',' '**' test] | '**' test)
    final public void arglist() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case LPAREN:
            case LBRACE:
            case LBRACKET:
            case PLUS:
            case MINUS:
            case NOT:
            case NOT_BOOL:
            case LAMBDA:
            case AS:
            case WITH:
            case NAME:
            case DECNUMBER:
            case HEXNUMBER:
            case OCTNUMBER:
            case FLOAT:
            case COMPLEX:
            case SINGLE_STRING:
            case SINGLE_STRING2:
            case TRIPLE_STRING:
            case TRIPLE_STRING2:
            case SINGLE_USTRING:
            case SINGLE_USTRING2:
            case TRIPLE_USTRING:
            case TRIPLE_USTRING2:
            case 136:
                normalargs();
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case COMMA:
                        grammarActions.findTokenAndAdd(",");
                        jj_consume_token(COMMA);
                        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                            case MULTIPLY:
                            case POWER:
                                if (jj_2_24(2)) {
                                    ExtraArgValueList();
                                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                        case COMMA:
                                            grammarActions.findTokenAndAdd(",");
                                            jj_consume_token(COMMA);
                                            ExtraKeywordValueList();
                                            break;
                                        default:
                                            jj_la1[121] = jj_gen;
                                            ;
                                    }
                                } else {
                                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                        case MULTIPLY:
                                        case POWER:
                                            ExtraKeywordValueList();
                                            break;
                                        default:
                                            jj_la1[122] = jj_gen;
                                            jj_consume_token(-1);
                                            throw new ParseException();
                                    }
                                }
                                break;
                            default:
                                jj_la1[123] = jj_gen;
                                ;
                        }
                        break;
                    default:
                        jj_la1[124] = jj_gen;
                        ;
                }
                break;
            default:
                jj_la1[128] = jj_gen;
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case MULTIPLY:
                    case POWER:
                        if (jj_2_25(2)) {
                            ExtraArgValueList();
                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                case COMMA:
                                    grammarActions.findTokenAndAdd(",");
                                    jj_consume_token(COMMA);
                                    ExtraKeywordValueList();
                                    break;
                                default:
                                    jj_la1[125] = jj_gen;
                                    ;
                            }
                        } else {
                            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                                case MULTIPLY:
                                case POWER:
                                    ExtraKeywordValueList();
                                    break;
                                default:
                                    jj_la1[126] = jj_gen;
                                    jj_consume_token(-1);
                                    throw new ParseException();
                            }
                        }
                        break;
                    default:
                        jj_la1[127] = jj_gen;
                        ;
                }
        }
    }

    final public void normalargs() throws ParseException {
        argument();
        label_40: while (true) {
            if (jj_2_26(2)) {
                ;
            } else {
                break label_40;
            }
            grammarActions.findTokenAndAdd(",");
            jj_consume_token(COMMA);
            argument();
        }
    }

    final public void ExtraArgValueList() throws ParseException {
        /*@bgen(jjtree) ExtraArgValueList */
        SimpleNode jjtn000 = builder.openNode(JJTEXTRAARGVALUELIST);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            grammarActions.addSpecialToken(grammarActions.createSpecialStr("*", false));
            jj_consume_token(MULTIPLY);
            test();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void ExtraKeywordValueList() throws ParseException {
        /*@bgen(jjtree) ExtraKeywordValueList */
        SimpleNode jjtn000 = builder.openNode(JJTEXTRAKEYWORDVALUELIST);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case POWER:
                    grammarActions.addSpecialToken(grammarActions.createSpecialStr("**", false));
                    jj_consume_token(POWER);
                    break;
                case MULTIPLY:
                    grammarActions.addSpecialToken(grammarActions.createSpecialStr("**", false));
                    jj_consume_token(MULTIPLY);
                    jj_consume_token(MULTIPLY);
                    break;
                default:
                    jj_la1[129] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            test();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    //argument: [test '='] test     # Really [keyword '='] test
    final public void argument() throws ParseException {
        SimpleNode jjtn001 = builder.openNode(JJTKEYWORD);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        jjtreeOpenNodeScope(jjtn001);
        try {
            if (jj_2_27(2)) {
                Name();
                grammarActions.findTokenAndAdd("=");
                jj_consume_token(EQUAL);
            } else {
                ;
            }
            test();
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
                jjtreeCloseNodeScope(jjtn001);
            }
        }
    }

    final public void Number() throws ParseException {
        /*@bgen(jjtree) Num */
        SimpleNode jjtn000 = builder.openNode(JJTNUM);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token t;
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case HEXNUMBER:
                    t = jj_consume_token(HEXNUMBER);
                    grammarActions.makeIntSub2(t, 16, t, (Num) jjtn000);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtreeCloseNodeScope(jjtn000);

                    break;
                case OCTNUMBER:
                    t = jj_consume_token(OCTNUMBER);
                    grammarActions.makeInt(t, 8, t, (Num) jjtn000);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtreeCloseNodeScope(jjtn000);

                    break;
                case DECNUMBER:
                    t = jj_consume_token(DECNUMBER);
                    grammarActions.makeInt(t, 10, t, (Num) jjtn000);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtreeCloseNodeScope(jjtn000);

                    break;
                case FLOAT:
                    t = jj_consume_token(FLOAT);
                    grammarActions.makeFloat(t, (Num) jjtn000);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtreeCloseNodeScope(jjtn000);

                    break;
                case COMPLEX:
                    t = jj_consume_token(COMPLEX);
                    grammarActions.makeComplex(t, (Num) jjtn000);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtreeCloseNodeScope(jjtn000);

                    break;
                default:
                    jj_la1[130] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public void Complex() throws ParseException {
        /*@bgen(jjtree) Complex */
        SimpleNode jjtn000 = builder.openNode(JJTCOMPLEX);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        try {
            jj_consume_token(FLOAT);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
    }

    final public Token Name() throws ParseException {
        /*@bgen(jjtree) Name */
        SimpleNode jjtn000 = builder.openNode(JJTNAME);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token t;
        try {
            try {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case NAME:
                        t = jj_consume_token(NAME);
                        break;
                    case AS:
                        t = jj_consume_token(AS);
                        break;
                    case WITH:
                        t = jj_consume_token(WITH);
                        break;
                    default:
                        jj_la1[131] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            } catch (ParseException e) {
                t = handleErrorInName(e);
            }
            if (acceptWithStmt && "with".equals(t.image)) {
                {
                    if (true)
                        throw withNameInvalidException;
                }
            }
            ((Name) jjtn000).id = t.image;
            {
                if (true)
                    return t;
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);

        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    final public Token Name2() throws ParseException {
        /*@bgen(jjtree) Name */
        SimpleNode jjtn000 = builder.openNode(JJTNAME);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtreeOpenNodeScope(jjtn000);
        Token t;
        try {
            try {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case NAME:
                        t = jj_consume_token(NAME);
                        break;
                    case AS:
                        t = jj_consume_token(AS);
                        break;
                    case PRINT:
                        t = jj_consume_token(PRINT);
                        break;
                    default:
                        jj_la1[132] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            } catch (ParseException e) {
                t = handleErrorInName(e);
            }
            ((Name) jjtn000).id = t.image;
            {
                if (true)
                    return t;
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtreeCloseNodeScope(jjtn000);

        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
                jjtreeCloseNodeScope(jjtn000);
            }
        }
        throw new Error("Missing return statement in function");
    }

    final public void String() throws ParseException {
        Token t;
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case SINGLE_STRING:
                SimpleNode jjtn001 = builder.openNode(JJTSTRING);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
                jjtreeOpenNodeScope(jjtn001);
                try {
                    t = jj_consume_token(SINGLE_STRING);
                    grammarActions.makeString(t, 1, (Str) jjtn001);
                    jjtree.closeNodeScope(jjtn001, true);
                    jjtc001 = false;
                    jjtreeCloseNodeScope(jjtn001);

                } finally {
                    if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, true);
                        jjtreeCloseNodeScope(jjtn001);
                    }
                }
                break;
            case SINGLE_STRING2:
                SimpleNode jjtn002 = builder.openNode(JJTSTRING);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
                jjtreeOpenNodeScope(jjtn002);
                try {
                    t = jj_consume_token(SINGLE_STRING2);
                    grammarActions.makeString(t, 1, (Str) jjtn002);
                    jjtree.closeNodeScope(jjtn002, true);
                    jjtc002 = false;
                    jjtreeCloseNodeScope(jjtn002);

                } finally {
                    if (jjtc002) {
                        jjtree.closeNodeScope(jjtn002, true);
                        jjtreeCloseNodeScope(jjtn002);
                    }
                }
                break;
            case TRIPLE_STRING:
                SimpleNode jjtn003 = builder.openNode(JJTSTRING);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
                jjtreeOpenNodeScope(jjtn003);
                try {
                    t = jj_consume_token(TRIPLE_STRING);
                    grammarActions.makeString(t, 3, (Str) jjtn003);
                    jjtree.closeNodeScope(jjtn003, true);
                    jjtc003 = false;
                    jjtreeCloseNodeScope(jjtn003);

                } finally {
                    if (jjtc003) {
                        jjtree.closeNodeScope(jjtn003, true);
                        jjtreeCloseNodeScope(jjtn003);
                    }
                }
                break;
            case TRIPLE_STRING2:
                SimpleNode jjtn004 = builder.openNode(JJTSTRING);
                boolean jjtc004 = true;
                jjtree.openNodeScope(jjtn004);
                jjtreeOpenNodeScope(jjtn004);
                try {
                    t = jj_consume_token(TRIPLE_STRING2);
                    grammarActions.makeString(t, 3, (Str) jjtn004);
                    jjtree.closeNodeScope(jjtn004, true);
                    jjtc004 = false;
                    jjtreeCloseNodeScope(jjtn004);

                } finally {
                    if (jjtc004) {
                        jjtree.closeNodeScope(jjtn004, true);
                        jjtreeCloseNodeScope(jjtn004);
                    }
                }
                break;
            case SINGLE_USTRING:
                SimpleNode jjtn005 = builder.openNode(JJTUNICODE);
                boolean jjtc005 = true;
                jjtree.openNodeScope(jjtn005);
                jjtreeOpenNodeScope(jjtn005);
                try {
                    t = jj_consume_token(SINGLE_USTRING);
                    grammarActions.makeString(t, 1, (Str) jjtn005);
                    jjtree.closeNodeScope(jjtn005, true);
                    jjtc005 = false;
                    jjtreeCloseNodeScope(jjtn005);

                } finally {
                    if (jjtc005) {
                        jjtree.closeNodeScope(jjtn005, true);
                        jjtreeCloseNodeScope(jjtn005);
                    }
                }
                break;
            case SINGLE_USTRING2:
                SimpleNode jjtn006 = builder.openNode(JJTUNICODE);
                boolean jjtc006 = true;
                jjtree.openNodeScope(jjtn006);
                jjtreeOpenNodeScope(jjtn006);
                try {
                    t = jj_consume_token(SINGLE_USTRING2);
                    grammarActions.makeString(t, 1, (Str) jjtn006);
                    jjtree.closeNodeScope(jjtn006, true);
                    jjtc006 = false;
                    jjtreeCloseNodeScope(jjtn006);

                } finally {
                    if (jjtc006) {
                        jjtree.closeNodeScope(jjtn006, true);
                        jjtreeCloseNodeScope(jjtn006);
                    }
                }
                break;
            case TRIPLE_USTRING:
                SimpleNode jjtn007 = builder.openNode(JJTUNICODE);
                boolean jjtc007 = true;
                jjtree.openNodeScope(jjtn007);
                jjtreeOpenNodeScope(jjtn007);
                try {
                    t = jj_consume_token(TRIPLE_USTRING);
                    grammarActions.makeString(t, 3, (Str) jjtn007);
                    jjtree.closeNodeScope(jjtn007, true);
                    jjtc007 = false;
                    jjtreeCloseNodeScope(jjtn007);

                } finally {
                    if (jjtc007) {
                        jjtree.closeNodeScope(jjtn007, true);
                        jjtreeCloseNodeScope(jjtn007);
                    }
                }
                break;
            case TRIPLE_USTRING2:
                SimpleNode jjtn008 = builder.openNode(JJTUNICODE);
                boolean jjtc008 = true;
                jjtree.openNodeScope(jjtn008);
                jjtreeOpenNodeScope(jjtn008);
                try {
                    t = jj_consume_token(TRIPLE_USTRING2);
                    grammarActions.makeString(t, 3, (Str) jjtn008);
                    jjtree.closeNodeScope(jjtn008, true);
                    jjtc008 = false;
                    jjtreeCloseNodeScope(jjtn008);

                } finally {
                    if (jjtc008) {
                        jjtree.closeNodeScope(jjtn008, true);
                        jjtreeCloseNodeScope(jjtn008);
                    }
                }
                break;
            default:
                jj_la1[133] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    private boolean jj_2_1(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_1();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(0, xla);
        }
    }

    private boolean jj_2_2(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_2();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(1, xla);
        }
    }

    private boolean jj_2_3(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_3();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(2, xla);
        }
    }

    private boolean jj_2_4(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_4();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(3, xla);
        }
    }

    private boolean jj_2_5(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_5();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(4, xla);
        }
    }

    private boolean jj_2_6(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_6();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(5, xla);
        }
    }

    private boolean jj_2_7(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_7();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(6, xla);
        }
    }

    private boolean jj_2_8(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_8();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(7, xla);
        }
    }

    private boolean jj_2_9(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_9();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(8, xla);
        }
    }

    private boolean jj_2_10(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_10();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(9, xla);
        }
    }

    private boolean jj_2_11(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_11();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(10, xla);
        }
    }

    private boolean jj_2_12(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_12();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(11, xla);
        }
    }

    private boolean jj_2_13(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_13();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(12, xla);
        }
    }

    private boolean jj_2_14(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_14();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(13, xla);
        }
    }

    private boolean jj_2_15(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_15();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(14, xla);
        }
    }

    private boolean jj_2_16(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_16();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(15, xla);
        }
    }

    private boolean jj_2_17(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_17();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(16, xla);
        }
    }

    private boolean jj_2_18(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_18();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(17, xla);
        }
    }

    private boolean jj_2_19(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_19();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(18, xla);
        }
    }

    private boolean jj_2_20(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_20();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(19, xla);
        }
    }

    private boolean jj_2_21(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_21();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(20, xla);
        }
    }

    private boolean jj_2_22(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_22();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(21, xla);
        }
    }

    private boolean jj_2_23(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_23();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(22, xla);
        }
    }

    private boolean jj_2_24(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_24();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(23, xla);
        }
    }

    private boolean jj_2_25(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_25();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(24, xla);
        }
    }

    private boolean jj_2_26(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_26();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(25, xla);
        }
    }

    private boolean jj_2_27(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_27();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(26, xla);
        }
    }

    private boolean jj_3R_70() {
        if (jj_3R_91())
            return true;
        return false;
    }

    private boolean jj_3R_98() {
        if (jj_3R_52())
            return true;
        return false;
    }

    private boolean jj_3_5() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_44())
            return true;
        return false;
    }

    private boolean jj_3_17() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_51())
            return true;
        return false;
    }

    private boolean jj_3R_96() {
        if (jj_3R_113())
            return true;
        return false;
    }

    private boolean jj_3R_60() {
        if (jj_scan_token(LPAREN))
            return true;
        return false;
    }

    private boolean jj_3R_80() {
        if (jj_3R_96())
            return true;
        return false;
    }

    private boolean jj_3R_79() {
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_51() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_78()) {
            jj_scanpos = xsp;
            if (jj_3R_79()) {
                jj_scanpos = xsp;
                if (jj_3R_80())
                    return true;
            }
        }
        return false;
    }

    private boolean jj_3R_78() {
        if (jj_scan_token(DOT))
            return true;
        return false;
    }

    private boolean jj_3R_44() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_59()) {
            jj_scanpos = xsp;
            if (jj_3R_60())
                return true;
        }
        return false;
    }

    private boolean jj_3R_59() {
        if (jj_3R_56())
            return true;
        return false;
    }

    private boolean jj_3R_41() {
        if (jj_3R_44())
            return true;
        return false;
    }

    private boolean jj_3_1() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_41())
            return true;
        return false;
    }

    private boolean jj_3R_43() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_57()) {
            jj_scanpos = xsp;
            if (jj_3R_58())
                return true;
        }
        return false;
    }

    private boolean jj_3R_57() {
        if (jj_scan_token(POWER))
            return true;
        return false;
    }

    private boolean jj_3R_151() {
        if (jj_scan_token(TRIPLE_USTRING2))
            return true;
        return false;
    }

    private boolean jj_3_4() {
        if (jj_3R_42())
            return true;
        return false;
    }

    private boolean jj_3R_150() {
        if (jj_scan_token(TRIPLE_USTRING))
            return true;
        return false;
    }

    private boolean jj_3R_42() {
        if (jj_scan_token(MULTIPLY))
            return true;
        if (jj_3R_56())
            return true;
        return false;
    }

    private boolean jj_3R_149() {
        if (jj_scan_token(SINGLE_USTRING2))
            return true;
        return false;
    }

    private boolean jj_3R_148() {
        if (jj_scan_token(SINGLE_USTRING))
            return true;
        return false;
    }

    private boolean jj_3_3() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_43())
            return true;
        return false;
    }

    private boolean jj_3R_147() {
        if (jj_scan_token(TRIPLE_STRING2))
            return true;
        return false;
    }

    private boolean jj_3R_91() {
        if (jj_scan_token(LAMBDA))
            return true;
        return false;
    }

    private boolean jj_3_2() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_42())
            return true;
        return false;
    }

    private boolean jj_3R_146() {
        if (jj_scan_token(TRIPLE_STRING))
            return true;
        return false;
    }

    private boolean jj_3R_145() {
        if (jj_scan_token(SINGLE_STRING2))
            return true;
        return false;
    }

    private boolean jj_3R_144() {
        if (jj_scan_token(SINGLE_STRING))
            return true;
        return false;
    }

    private boolean jj_3R_136() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_144()) {
            jj_scanpos = xsp;
            if (jj_3R_145()) {
                jj_scanpos = xsp;
                if (jj_3R_146()) {
                    jj_scanpos = xsp;
                    if (jj_3R_147()) {
                        jj_scanpos = xsp;
                        if (jj_3R_148()) {
                            jj_scanpos = xsp;
                            if (jj_3R_149()) {
                                jj_scanpos = xsp;
                                if (jj_3R_150()) {
                                    jj_scanpos = xsp;
                                    if (jj_3R_151())
                                        return true;
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    private boolean jj_3R_48() {
        if (jj_3R_76())
            return true;
        return false;
    }

    private boolean jj_3R_131() {
        if (jj_3R_136())
            return true;
        return false;
    }

    private boolean jj_3R_130() {
        if (jj_3R_135())
            return true;
        return false;
    }

    private boolean jj_3R_129() {
        if (jj_3R_56())
            return true;
        return false;
    }

    private boolean jj_3R_128() {
        if (jj_scan_token(136))
            return true;
        return false;
    }

    private boolean jj_3R_50() {
        if (jj_3R_48())
            return true;
        return false;
    }

    private boolean jj_3R_127() {
        if (jj_scan_token(LBRACE))
            return true;
        return false;
    }

    private boolean jj_3R_108() {
        if (jj_scan_token(FROM))
            return true;
        return false;
    }

    private boolean jj_3R_126() {
        if (jj_scan_token(LBRACKET))
            return true;
        return false;
    }

    private boolean jj_3R_107() {
        if (jj_scan_token(IMPORT))
            return true;
        return false;
    }

    private boolean jj_3R_120() {
        if (jj_3R_132())
            return true;
        return false;
    }

    private boolean jj_3R_125() {
        if (jj_scan_token(LPAREN))
            return true;
        return false;
    }

    private boolean jj_3R_88() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_107()) {
            jj_scanpos = xsp;
            if (jj_3R_108())
                return true;
        }
        return false;
    }

    private boolean jj_3R_49() {
        if (jj_3R_77())
            return true;
        return false;
    }

    private boolean jj_3_16() {
        if (jj_scan_token(LPAREN))
            return true;
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_49()) {
            jj_scanpos = xsp;
            if (jj_3R_50())
                return true;
        }
        return false;
    }

    private boolean jj_3R_117() {
        if (jj_scan_token(RAISE))
            return true;
        return false;
    }

    private boolean jj_3R_119() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_15()) {
            jj_scanpos = xsp;
            if (jj_3_16()) {
                jj_scanpos = xsp;
                if (jj_3R_125()) {
                    jj_scanpos = xsp;
                    if (jj_3R_126()) {
                        jj_scanpos = xsp;
                        if (jj_3R_127()) {
                            jj_scanpos = xsp;
                            if (jj_3R_128()) {
                                jj_scanpos = xsp;
                                if (jj_3R_129()) {
                                    jj_scanpos = xsp;
                                    if (jj_3R_130()) {
                                        jj_scanpos = xsp;
                                        if (jj_3R_131())
                                            return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    private boolean jj_3_15() {
        if (jj_scan_token(LPAREN))
            return true;
        if (jj_scan_token(RPAREN))
            return true;
        return false;
    }

    private boolean jj_3R_77() {
        if (jj_scan_token(YIELD))
            return true;
        return false;
    }

    private boolean jj_3R_56() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_scan_token(92)) {
            jj_scanpos = xsp;
            if (jj_scan_token(89)) {
                jj_scanpos = xsp;
                if (jj_scan_token(90))
                    return true;
            }
        }
        return false;
    }

    private boolean jj_3R_116() {
        if (jj_3R_77())
            return true;
        return false;
    }

    private boolean jj_3R_122() {
        if (jj_scan_token(RETURN))
            return true;
        return false;
    }

    private boolean jj_3R_115() {
        if (jj_3R_122())
            return true;
        return false;
    }

    private boolean jj_3_12() {
        if (jj_scan_token(POWER))
            return true;
        if (jj_3R_47())
            return true;
        return false;
    }

    private boolean jj_3_14() {
        if (jj_scan_token(LPAREN))
            return true;
        if (jj_3R_48())
            return true;
        return false;
    }

    private boolean jj_3R_106() {
        if (jj_3R_117())
            return true;
        return false;
    }

    private boolean jj_3R_143() {
        if (jj_scan_token(COMPLEX))
            return true;
        return false;
    }

    private boolean jj_3R_105() {
        if (jj_3R_116())
            return true;
        return false;
    }

    private boolean jj_3R_104() {
        if (jj_3R_115())
            return true;
        return false;
    }

    private boolean jj_3R_103() {
        if (jj_scan_token(CONTINUE))
            return true;
        return false;
    }

    private boolean jj_3R_142() {
        if (jj_scan_token(FLOAT))
            return true;
        return false;
    }

    private boolean jj_3R_102() {
        if (jj_scan_token(BREAK))
            return true;
        return false;
    }

    private boolean jj_3R_87() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_102()) {
            jj_scanpos = xsp;
            if (jj_3R_103()) {
                jj_scanpos = xsp;
                if (jj_3R_104()) {
                    jj_scanpos = xsp;
                    if (jj_3R_105()) {
                        jj_scanpos = xsp;
                        if (jj_3R_106())
                            return true;
                    }
                }
            }
        }
        return false;
    }

    private boolean jj_3_13() {
        if (jj_scan_token(LPAREN))
            return true;
        if (jj_scan_token(RPAREN))
            return true;
        return false;
    }

    private boolean jj_3R_141() {
        if (jj_scan_token(DECNUMBER))
            return true;
        return false;
    }

    private boolean jj_3R_110() {
        if (jj_3R_119())
            return true;
        return false;
    }

    private boolean jj_3R_86() {
        if (jj_scan_token(PASS))
            return true;
        return false;
    }

    private boolean jj_3R_140() {
        if (jj_scan_token(OCTNUMBER))
            return true;
        return false;
    }

    private boolean jj_3R_93() {
        if (jj_3R_110())
            return true;
        return false;
    }

    private boolean jj_3R_75() {
        if (jj_3R_93())
            return true;
        return false;
    }

    private boolean jj_3R_139() {
        if (jj_scan_token(HEXNUMBER))
            return true;
        return false;
    }

    private boolean jj_3R_135() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_139()) {
            jj_scanpos = xsp;
            if (jj_3R_140()) {
                jj_scanpos = xsp;
                if (jj_3R_141()) {
                    jj_scanpos = xsp;
                    if (jj_3R_142()) {
                        jj_scanpos = xsp;
                        if (jj_3R_143())
                            return true;
                    }
                }
            }
        }
        return false;
    }

    private boolean jj_3R_74() {
        if (jj_scan_token(NOT))
            return true;
        return false;
    }

    private boolean jj_3R_101() {
        if (jj_scan_token(DEL))
            return true;
        return false;
    }

    private boolean jj_3R_73() {
        if (jj_scan_token(MINUS))
            return true;
        return false;
    }

    private boolean jj_3R_47() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_72()) {
            jj_scanpos = xsp;
            if (jj_3R_73()) {
                jj_scanpos = xsp;
                if (jj_3R_74()) {
                    jj_scanpos = xsp;
                    if (jj_3R_75())
                        return true;
                }
            }
        }
        return false;
    }

    private boolean jj_3R_72() {
        if (jj_scan_token(PLUS))
            return true;
        return false;
    }

    private boolean jj_3_8() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_85() {
        if (jj_3R_101())
            return true;
        return false;
    }

    private boolean jj_3_7() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3_27() {
        if (jj_3R_56())
            return true;
        if (jj_scan_token(EQUAL))
            return true;
        return false;
    }

    private boolean jj_3R_100() {
        if (jj_scan_token(PRINT))
            return true;
        return false;
    }

    private boolean jj_3R_55() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_27())
            jj_scanpos = xsp;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_133() {
        if (jj_3R_47())
            return true;
        return false;
    }

    private boolean jj_3_26() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_55())
            return true;
        return false;
    }

    private boolean jj_3_10() {
        if (jj_scan_token(PRINT))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_138() {
        if (jj_scan_token(MULTIPLY))
            return true;
        return false;
    }

    private boolean jj_3_22() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_137() {
        if (jj_scan_token(POWER))
            return true;
        return false;
    }

    private boolean jj_3R_132() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_137()) {
            jj_scanpos = xsp;
            if (jj_3R_138())
                return true;
        }
        return false;
    }

    private boolean jj_3_9() {
        if (jj_scan_token(PRINT))
            return true;
        if (jj_scan_token(RSHIFT))
            return true;
        return false;
    }

    private boolean jj_3R_84() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_9()) {
            jj_scanpos = xsp;
            if (jj_3_10()) {
                jj_scanpos = xsp;
                if (jj_3R_100())
                    return true;
            }
        }
        return false;
    }

    private boolean jj_3R_121() {
        if (jj_3R_133())
            return true;
        return false;
    }

    private boolean jj_3R_54() {
        if (jj_scan_token(MULTIPLY))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_111() {
        if (jj_3R_55())
            return true;
        return false;
    }

    private boolean jj_3R_114() {
        if (jj_3R_121())
            return true;
        return false;
    }

    private boolean jj_3R_112() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_25()) {
            jj_scanpos = xsp;
            if (jj_3R_120())
                return true;
        }
        return false;
    }

    private boolean jj_3_25() {
        if (jj_3R_54())
            return true;
        return false;
    }

    private boolean jj_3R_95() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_112())
            jj_scanpos = xsp;
        return false;
    }

    private boolean jj_3_24() {
        if (jj_3R_54())
            return true;
        return false;
    }

    private boolean jj_3R_124() {
        if (jj_3R_134())
            return true;
        return false;
    }

    private boolean jj_3R_94() {
        if (jj_3R_111())
            return true;
        return false;
    }

    private boolean jj_3R_76() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_94()) {
            jj_scanpos = xsp;
            if (jj_3R_95())
                return true;
        }
        return false;
    }

    private boolean jj_3R_53() {
        if (jj_3R_82())
            return true;
        return false;
    }

    private boolean jj_3R_97() {
        if (jj_3R_114())
            return true;
        return false;
    }

    private boolean jj_3R_83() {
        if (jj_3R_99())
            return true;
        return false;
    }

    private boolean jj_3R_81() {
        if (jj_3R_97())
            return true;
        return false;
    }

    private boolean jj_3R_58() {
        if (jj_scan_token(MULTIPLY))
            return true;
        return false;
    }

    private boolean jj_3R_52() {
        if (jj_3R_81())
            return true;
        return false;
    }

    private boolean jj_3R_69() {
        if (jj_scan_token(ASSERT))
            return true;
        return false;
    }

    private boolean jj_3_11() {
        if (jj_scan_token(IS))
            return true;
        if (jj_scan_token(NOT_BOOL))
            return true;
        return false;
    }

    private boolean jj_3_23() {
        Token xsp;
        if (jj_3R_53())
            return true;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_53()) {
                jj_scanpos = xsp;
                break;
            }
        }
        return false;
    }

    private boolean jj_3R_82() {
        if (jj_scan_token(FOR))
            return true;
        if (jj_3R_98())
            return true;
        return false;
    }

    private boolean jj_3R_68() {
        if (jj_3R_90())
            return true;
        return false;
    }

    private boolean jj_3R_67() {
        if (jj_3R_89())
            return true;
        return false;
    }

    private boolean jj_3R_66() {
        if (jj_3R_88())
            return true;
        return false;
    }

    private boolean jj_3_6() {
        if (jj_scan_token(SEMICOLON))
            return true;
        if (jj_3R_45())
            return true;
        return false;
    }

    private boolean jj_3R_65() {
        if (jj_3R_87())
            return true;
        return false;
    }

    private boolean jj_3R_64() {
        if (jj_3R_86())
            return true;
        return false;
    }

    private boolean jj_3R_63() {
        if (jj_3R_85())
            return true;
        return false;
    }

    private boolean jj_3R_62() {
        if (jj_3R_84())
            return true;
        return false;
    }

    private boolean jj_3R_45() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_61()) {
            jj_scanpos = xsp;
            if (jj_3R_62()) {
                jj_scanpos = xsp;
                if (jj_3R_63()) {
                    jj_scanpos = xsp;
                    if (jj_3R_64()) {
                        jj_scanpos = xsp;
                        if (jj_3R_65()) {
                            jj_scanpos = xsp;
                            if (jj_3R_66()) {
                                jj_scanpos = xsp;
                                if (jj_3R_67()) {
                                    jj_scanpos = xsp;
                                    if (jj_3R_68()) {
                                        jj_scanpos = xsp;
                                        if (jj_3R_69())
                                            return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    private boolean jj_3R_61() {
        if (jj_3R_83())
            return true;
        return false;
    }

    private boolean jj_3_21() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_134() {
        if (jj_3R_52())
            return true;
        return false;
    }

    private boolean jj_3R_123() {
        if (jj_scan_token(NOT_BOOL))
            return true;
        return false;
    }

    private boolean jj_3R_118() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_123()) {
            jj_scanpos = xsp;
            if (jj_3R_124())
                return true;
        }
        return false;
    }

    private boolean jj_3R_109() {
        if (jj_3R_118())
            return true;
        return false;
    }

    private boolean jj_3R_71() {
        if (jj_3R_92())
            return true;
        return false;
    }

    private boolean jj_3_20() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_90() {
        if (jj_scan_token(EXEC))
            return true;
        return false;
    }

    private boolean jj_3_19() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_113() {
        if (jj_scan_token(COLON))
            return true;
        return false;
    }

    private boolean jj_3R_92() {
        if (jj_3R_109())
            return true;
        return false;
    }

    private boolean jj_3R_89() {
        if (jj_scan_token(GLOBAL))
            return true;
        return false;
    }

    private boolean jj_3_18() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_52())
            return true;
        return false;
    }

    private boolean jj_3R_99() {
        if (jj_3R_46())
            return true;
        return false;
    }

    private boolean jj_3R_46() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_70()) {
            jj_scanpos = xsp;
            if (jj_3R_71())
                return true;
        }
        return false;
    }

    /** Generated Token Manager. */
    public PythonGrammar25TokenManager token_source;
    /** Current token. */
    public Token token;
    /** Next token. */
    public Token jj_nt;
    private int jj_ntk;
    private Token jj_scanpos, jj_lastpos;
    private int jj_la;
    private int jj_gen;
    final private int[] jj_la1 = new int[134];
    static private int[] jj_la1_0;
    static private int[] jj_la1_1;
    static private int[] jj_la1_2;
    static private int[] jj_la1_3;
    static private int[] jj_la1_4;
    static {
        jj_la1_init_0();
        jj_la1_init_1();
        jj_la1_init_2();
        jj_la1_init_3();
        jj_la1_init_4();
    }

    private static void jj_la1_init_0() {
        jj_la1_0 = new int[] { 0x182a0040, 0x182a0040, 0x0, 0x20000, 0x20020000, 0x1000000, 0x1000000, 0x20000000,
                0x20020000, 0x20000000, 0x0, 0x20000, 0x1000000, 0x182a0000, 0x800000, 0x182a0000, 0x182a0000,
                0x182a0000, 0x182a0000, 0x182a0000, 0x182a0000, 0x182a0000, 0x182a0000, 0x182a0000, 0x182a0000,
                0x182a0000, 0x182a0000, 0x182a0000, 0x0, 0x182a0000, 0x0, 0x1000000, 0x1000000, 0x1000000, 0x0, 0x0,
                0x182a0000, 0x182a0000, 0x1000000, 0x1000000, 0x182a0000, 0x0, 0x1000000, 0x2000000, 0x0, 0x1000000,
                0x1000000, 0x0, 0x20020000, 0x0, 0x2000000, 0x0, 0x1000000, 0x1000000, 0x0, 0x1000000, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1000000, 0x182a0000, 0x0, 0x182a0000, 0x182a0000, 0x182a4040,
                0x1000000, 0x1000000, 0x1000000, 0x182a0000, 0x20020000, 0x0, 0x182a0000, 0x0, 0x0, 0x182a0000, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18000000, 0x18000000, 0xe0000000, 0xe0000000, 0x182a0000,
                0x2220000, 0x2200000, 0x0, 0x182a0000, 0x182a0000, 0x182a0000, 0x0, 0x2a0000, 0x0, 0x20020000,
                0x1000000, 0x4000000, 0x1e2a0000, 0x182a0000, 0x182a0000, 0x4000000, 0x1000000, 0x1000000, 0x1000000,
                0x1000000, 0x0, 0x1000000, 0x0, 0x0, 0x0, 0x182a0000, 0x20000, 0x1000000, 0x20000000, 0x20000000,
                0x1000000, 0x1000000, 0x20000000, 0x20000000, 0x182a0000, 0x20000000, 0x0, 0x0, 0x0, 0x0, };
    }

    private static void jj_la1_init_1() {
        jj_la1_1 = new int[] { 0x40000010, 0x40000010, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1, 0x1, 0x1, 0x100, 0x0, 0x0,
                0x40000010, 0x0, 0x40000010, 0x40000010, 0x40000010, 0x40000010, 0x40000010, 0x40000010, 0x40000010,
                0x40000010, 0x40000010, 0x40000010, 0x40000010, 0x40000010, 0x40000010, 0x100, 0x40000010, 0xfff0000,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x40000010, 0x40000010, 0x0, 0x0, 0x40000010, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x40000010, 0x0, 0x40000010, 0x40000010, 0x40000010, 0x0, 0x0, 0x0, 0x40000010, 0x1, 0x0, 0x40000010,
                0x10000000, 0x20000000, 0x40000010, 0xc000fe00, 0x4000fe00, 0x80000000, 0x40, 0x20, 0x80, 0x6, 0x6,
                0x0, 0x0, 0x8, 0x8, 0x10, 0x0, 0x0, 0x0, 0x40000010, 0x40000010, 0x40000010, 0x0, 0x0, 0x0, 0x1, 0x0,
                0x0, 0x40000010, 0x40000010, 0x40000010, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40000010,
                0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x40000010, 0x1, 0x0, 0x0, 0x0, 0x0, };
    }

    private static void jj_la1_init_2() {
        jj_la1_2 = new int[] { 0xdffff6e6, 0xdffff6e6, 0x8000000, 0x0, 0x16000000, 0x0, 0x0, 0x0, 0x16000000, 0x0, 0x0,
                0x16000000, 0x0, 0xdffff6e6, 0x0, 0xd7fff002, 0xd6020002, 0xd6020002, 0xd6020002, 0xd6020002,
                0xd6020002, 0xd6020002, 0xd6020002, 0xd6020002, 0xd6020002, 0xd6020002, 0xd6020002, 0xd6020002, 0x0,
                0xd6020002, 0x0, 0x0, 0x0, 0x0, 0x1000, 0x23c000, 0xd6000002, 0xd6000002, 0x0, 0x0, 0xd6000002,
                0xc0000, 0x0, 0x0, 0x16000000, 0x0, 0x0, 0x16000000, 0x16000000, 0x2000000, 0x0, 0x2000000, 0x0, 0x0,
                0x1, 0x0, 0x80006e4, 0x10, 0x8, 0x8, 0x8, 0x100, 0x8, 0x800, 0x900, 0x0, 0xd6000002, 0x2000000,
                0xdffff6e6, 0xdffff6e6, 0xd7fff002, 0x0, 0x0, 0x0, 0xd6000002, 0x16000000, 0x4, 0xd6000002, 0x0, 0x0,
                0xd6000000, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd6000000, 0x0, 0x0, 0x20000,
                0xd6000002, 0xd6000002, 0xd6000002, 0x0, 0xd6000000, 0x40, 0x16000000, 0x0, 0x0, 0xd6000002,
                0xd6000002, 0xd6000002, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x44, 0x44, 0x44, 0xd6000002, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd6000002, 0x0, 0xc0000000, 0x16000000, 0x12001000, 0x0, };
    }

    private static void jj_la1_init_3() {
        jj_la1_3 = new int[] { 0x1fe007, 0x1fe007, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1fe007,
                0x0, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007,
                0x1fe007, 0x1fe007, 0x1fe007, 0x1fe007, 0x0, 0x1fe007, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1fe007,
                0x1fe007, 0x0, 0x0, 0x1fe007, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1fe007, 0x0, 0x1fe007, 0x1fe007, 0x1fe007,
                0x0, 0x0, 0x0, 0x1fe007, 0x0, 0x0, 0x1fe007, 0x0, 0x0, 0x1fe007, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x1fe007, 0x0, 0x0, 0x0, 0x1fe007, 0x1fe007, 0x1fe007, 0x1fe000, 0x1fe007,
                0x0, 0x0, 0x0, 0x0, 0x1fe007, 0x1fe007, 0x1fe007, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x1fe007, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1fe007, 0x0, 0x7, 0x0, 0x0, 0x1fe000, };
    }

    private static void jj_la1_init_4() {
        jj_la1_4 = new int[] { 0x100, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x100,
                0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x0, 0x100, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x100, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x100,
                0x100, 0x100, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0, 0x100, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x100, 0x100, 0x100, 0x0, 0x100, 0x0, 0x0, 0x0,
                0x0, 0x100, 0x100, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x0,
                0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0, };
    }

    final private JJCalls[] jj_2_rtns = new JJCalls[27];
    private boolean jj_rescan = false;
    private int jj_gc = 0;

    /** Constructor with user supplied FastCharStream. */
    public PythonGrammar25(boolean generateTree, FastCharStream stream) {
        super(generateTree);
        builder = jjtree.builder;
        token_source = new PythonGrammar25TokenManager(stream);
        token = new Token();
        jj_ntk = -1;
        jj_gen = 0;
        for (int i = 0; i < 134; i++)
            jj_la1[i] = -1;
        for (int i = 0; i < jj_2_rtns.length; i++)
            jj_2_rtns[i] = new JJCalls();
    }

    /** Reinitialise. */
    //Removed Reinit}

    /** Constructor with generated Token Manager. */
    public PythonGrammar25(boolean generateTree, PythonGrammar25TokenManager tm) {
        super(generateTree);
        builder = jjtree.builder;
        token_source = tm;
        token = new Token();
        jj_ntk = -1;
        jj_gen = 0;
        for (int i = 0; i < 134; i++)
            jj_la1[i] = -1;
        for (int i = 0; i < jj_2_rtns.length; i++)
            jj_2_rtns[i] = new JJCalls();
    }

    /** Reinitialise. */
    //Removed Reinit}

    private Token jj_consume_token(int kind) throws ParseException {
        Token oldToken;
        if ((oldToken = token).next != null)
            token = token.next;
        else
            token = token.next = token_source.getNextToken();
        jj_ntk = -1;
        if (token.kind == kind) {
            jj_gen++;
            if (++jj_gc > 100) {
                jj_gc = 0;
                for (int i = 0; i < jj_2_rtns.length; i++) {
                    JJCalls c = jj_2_rtns[i];
                    while (c != null) {
                        if (c.gen < jj_gen)
                            c.first = null;
                        c = c.next;
                    }
                }
            }
            return token;
        }
        token = oldToken;
        jj_kind = kind;
        throw generateParseException();
    }

    static private final class LookaheadSuccess extends java.lang.Error {
    }

    final private LookaheadSuccess jj_ls = new LookaheadSuccess();

    private boolean jj_scan_token(int kind) {
        if (jj_scanpos == jj_lastpos) {
            jj_la--;
            if (jj_scanpos.next == null) {
                jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
            } else {
                jj_lastpos = jj_scanpos = jj_scanpos.next;
            }
        } else {
            jj_scanpos = jj_scanpos.next;
        }
        if (jj_rescan) {
            int i = 0;
            Token tok = token;
            while (tok != null && tok != jj_scanpos) {
                i++;
                tok = tok.next;
            }
            if (tok != null)
                jj_add_error_token(kind, i);
        }
        if (jj_scanpos.kind != kind)
            return true;
        if (jj_la == 0 && jj_scanpos == jj_lastpos)
            throw jj_ls;
        return false;
    }

    /** Get the next Token. */
    final public Token getNextToken() {
        if (token.next != null)
            token = token.next;
        else
            token = token.next = token_source.getNextToken();
        jj_ntk = -1;
        jj_gen++;
        return token;
    }

    /** Get the specific Token. */
    final public Token getToken(int index) {
        Token t = token;
        for (int i = 0; i < index; i++) {
            if (t.next != null)
                t = t.next;
            else
                t = t.next = token_source.getNextToken();
        }
        return t;
    }

    private int jj_ntk() {
        if ((jj_nt = token.next) == null)
            return (jj_ntk = (token.next = token_source.getNextToken()).kind);
        else
            return (jj_ntk = jj_nt.kind);
    }

    private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
    private int[] jj_expentry;
    private int jj_kind = -1;
    private int[] jj_lasttokens = new int[100];
    private int jj_endpos;

    private void jj_add_error_token(int kind, int pos) {
        if (pos >= 100)
            return;
        if (pos == jj_endpos + 1) {
            jj_lasttokens[jj_endpos++] = kind;
        } else if (jj_endpos != 0) {
            jj_expentry = new int[jj_endpos];
            for (int i = 0; i < jj_endpos; i++) {
                jj_expentry[i] = jj_lasttokens[i];
            }
            jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
                int[] oldentry = (int[]) (it.next());
                if (oldentry.length == jj_expentry.length) {
                    for (int i = 0; i < jj_expentry.length; i++) {
                        if (oldentry[i] != jj_expentry[i]) {
                            continue jj_entries_loop;
                        }
                    }
                    jj_expentries.add(jj_expentry);
                    break jj_entries_loop;
                }
            }
            if (pos != 0)
                jj_lasttokens[(jj_endpos = pos) - 1] = kind;
        }
    }

    /** Generate ParseException. */
    public ParseException generateParseException() {
        jj_expentries.clear();
        boolean[] la1tokens = new boolean[137];
        if (jj_kind >= 0) {
            la1tokens[jj_kind] = true;
            jj_kind = -1;
        }
        for (int i = 0; i < 134; i++) {
            if (jj_la1[i] == jj_gen) {
                for (int j = 0; j < 32; j++) {
                    if ((jj_la1_0[i] & (1 << j)) != 0) {
                        la1tokens[j] = true;
                    }
                    if ((jj_la1_1[i] & (1 << j)) != 0) {
                        la1tokens[32 + j] = true;
                    }
                    if ((jj_la1_2[i] & (1 << j)) != 0) {
                        la1tokens[64 + j] = true;
                    }
                    if ((jj_la1_3[i] & (1 << j)) != 0) {
                        la1tokens[96 + j] = true;
                    }
                    if ((jj_la1_4[i] & (1 << j)) != 0) {
                        la1tokens[128 + j] = true;
                    }
                }
            }
        }
        for (int i = 0; i < 137; i++) {
            if (la1tokens[i]) {
                jj_expentry = new int[1];
                jj_expentry[0] = i;
                jj_expentries.add(jj_expentry);
            }
        }
        jj_endpos = 0;
        jj_rescan_token();
        jj_add_error_token(0, 0);
        int[][] exptokseq = new int[jj_expentries.size()][];
        for (int i = 0; i < jj_expentries.size(); i++) {
            exptokseq[i] = jj_expentries.get(i);
        }
        return new ParseException(token, exptokseq, tokenImage);
    }

    /** Enable tracing. */
    final public void enable_tracing() {
    }

    /** Disable tracing. */
    final public void disable_tracing() {
    }

    private void jj_rescan_token() {
        jj_rescan = true;
        for (int i = 0; i < 27; i++) {
            try {
                JJCalls p = jj_2_rtns[i];
                do {
                    if (p.gen > jj_gen) {
                        jj_la = p.arg;
                        jj_lastpos = jj_scanpos = p.first;
                        switch (i) {
                            case 0:
                                jj_3_1();
                                break;
                            case 1:
                                jj_3_2();
                                break;
                            case 2:
                                jj_3_3();
                                break;
                            case 3:
                                jj_3_4();
                                break;
                            case 4:
                                jj_3_5();
                                break;
                            case 5:
                                jj_3_6();
                                break;
                            case 6:
                                jj_3_7();
                                break;
                            case 7:
                                jj_3_8();
                                break;
                            case 8:
                                jj_3_9();
                                break;
                            case 9:
                                jj_3_10();
                                break;
                            case 10:
                                jj_3_11();
                                break;
                            case 11:
                                jj_3_12();
                                break;
                            case 12:
                                jj_3_13();
                                break;
                            case 13:
                                jj_3_14();
                                break;
                            case 14:
                                jj_3_15();
                                break;
                            case 15:
                                jj_3_16();
                                break;
                            case 16:
                                jj_3_17();
                                break;
                            case 17:
                                jj_3_18();
                                break;
                            case 18:
                                jj_3_19();
                                break;
                            case 19:
                                jj_3_20();
                                break;
                            case 20:
                                jj_3_21();
                                break;
                            case 21:
                                jj_3_22();
                                break;
                            case 22:
                                jj_3_23();
                                break;
                            case 23:
                                jj_3_24();
                                break;
                            case 24:
                                jj_3_25();
                                break;
                            case 25:
                                jj_3_26();
                                break;
                            case 26:
                                jj_3_27();
                                break;
                        }
                    }
                    p = p.next;
                } while (p != null);
            } catch (LookaheadSuccess ls) {
            }
        }
        jj_rescan = false;
    }

    private void jj_save(int index, int xla) {
        JJCalls p = jj_2_rtns[index];
        while (p.gen > jj_gen) {
            if (p.next == null) {
                p = p.next = new JJCalls();
                break;
            }
            p = p.next;
        }
        p.gen = jj_gen + xla - jj_la;
        p.first = token;
        p.arg = xla;
    }

    static final class JJCalls {
        int gen;
        Token first;
        int arg;
        JJCalls next;
    }

}
