Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
de.jplag.python3.grammar.Python3Parser Maven / Gradle / Ivy
// Generated from de/jplag/python3/grammar/Python3.g4 by ANTLR 4.12.0
package de.jplag.python3.grammar;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class Python3Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
STRING=1, NUMBER=2, INTEGER=3, DEF=4, RETURN=5, RAISE=6, FROM=7, IMPORT=8,
AS=9, GLOBAL=10, NONLOCAL=11, ASSERT=12, IF=13, ELIF=14, ELSE=15, WHILE=16,
FOR=17, IN=18, TRY=19, FINALLY=20, WITH=21, EXCEPT=22, LAMBDA=23, OR=24,
AND=25, NOT=26, IS=27, NONE=28, TRUE=29, FALSE=30, CLASS=31, YIELD=32,
DEL=33, PASS=34, CONTINUE=35, BREAK=36, ASYNC=37, AWAIT=38, NEWLINE=39,
NAME=40, STRING_LITERAL=41, BYTES_LITERAL=42, DECIMAL_INTEGER=43, OCT_INTEGER=44,
HEX_INTEGER=45, BIN_INTEGER=46, FLOAT_NUMBER=47, IMAG_NUMBER=48, DOT=49,
ELLIPSIS=50, STAR=51, OPEN_PAREN=52, CLOSE_PAREN=53, COMMA=54, COLON=55,
SEMI_COLON=56, POWER=57, ASSIGN=58, OPEN_BRACK=59, CLOSE_BRACK=60, OR_OP=61,
XOR=62, AND_OP=63, LEFT_SHIFT=64, RIGHT_SHIFT=65, ADD=66, MINUS=67, DIV=68,
MOD=69, IDIV=70, NOT_OP=71, OPEN_BRACE=72, CLOSE_BRACE=73, LESS_THAN=74,
GREATER_THAN=75, EQUALS=76, GT_EQ=77, LT_EQ=78, NOT_EQ_1=79, NOT_EQ_2=80,
AT=81, ARROW=82, ADD_ASSIGN=83, SUB_ASSIGN=84, MULT_ASSIGN=85, AT_ASSIGN=86,
DIV_ASSIGN=87, MOD_ASSIGN=88, AND_ASSIGN=89, OR_ASSIGN=90, XOR_ASSIGN=91,
LEFT_SHIFT_ASSIGN=92, RIGHT_SHIFT_ASSIGN=93, POWER_ASSIGN=94, IDIV_ASSIGN=95,
SKIP_=96, UNKNOWN_CHAR=97, INDENT=98, DEDENT=99;
public static final int
RULE_single_input = 0, RULE_file_input = 1, RULE_eval_input = 2, RULE_decorator = 3,
RULE_decorators = 4, RULE_decorated = 5, RULE_async_funcdef = 6, RULE_funcdef = 7,
RULE_parameters = 8, RULE_typedargslist = 9, RULE_tfpdef = 10, RULE_varargslist = 11,
RULE_vfpdef = 12, RULE_stmt = 13, RULE_simple_stmt = 14, RULE_small_stmt = 15,
RULE_expr_stmt = 16, RULE_annassign = 17, RULE_testlist_star_expr = 18,
RULE_augassign = 19, RULE_del_stmt = 20, RULE_pass_stmt = 21, RULE_flow_stmt = 22,
RULE_break_stmt = 23, RULE_continue_stmt = 24, RULE_return_stmt = 25,
RULE_yield_stmt = 26, RULE_raise_stmt = 27, RULE_import_stmt = 28, RULE_import_name = 29,
RULE_import_from = 30, RULE_import_as_name = 31, RULE_dotted_as_name = 32,
RULE_import_as_names = 33, RULE_dotted_as_names = 34, RULE_dotted_name = 35,
RULE_global_stmt = 36, RULE_nonlocal_stmt = 37, RULE_assert_stmt = 38,
RULE_compound_stmt = 39, RULE_async_stmt = 40, RULE_if_stmt = 41, RULE_while_stmt = 42,
RULE_for_stmt = 43, RULE_try_stmt = 44, RULE_with_stmt = 45, RULE_with_item = 46,
RULE_except_clause = 47, RULE_suite = 48, RULE_test = 49, RULE_test_nocond = 50,
RULE_lambdef = 51, RULE_lambdef_nocond = 52, RULE_or_test = 53, RULE_and_test = 54,
RULE_not_test = 55, RULE_comparison = 56, RULE_comp_op = 57, RULE_star_expr = 58,
RULE_expr = 59, RULE_xor_expr = 60, RULE_and_expr = 61, RULE_shift_expr = 62,
RULE_arith_expr = 63, RULE_term = 64, RULE_factor = 65, RULE_power = 66,
RULE_atom_expr = 67, RULE_atom = 68, RULE_testlist_comp = 69, RULE_trailer = 70,
RULE_subscriptlist = 71, RULE_subscript = 72, RULE_sliceop = 73, RULE_exprlist = 74,
RULE_testlist = 75, RULE_dictorsetmaker = 76, RULE_classdef = 77, RULE_arglist = 78,
RULE_argument = 79, RULE_comp_iter = 80, RULE_comp_for = 81, RULE_comp_if = 82,
RULE_encoding_decl = 83, RULE_yield_expr = 84, RULE_yield_arg = 85;
private static String[] makeRuleNames() {
return new String[] {
"single_input", "file_input", "eval_input", "decorator", "decorators",
"decorated", "async_funcdef", "funcdef", "parameters", "typedargslist",
"tfpdef", "varargslist", "vfpdef", "stmt", "simple_stmt", "small_stmt",
"expr_stmt", "annassign", "testlist_star_expr", "augassign", "del_stmt",
"pass_stmt", "flow_stmt", "break_stmt", "continue_stmt", "return_stmt",
"yield_stmt", "raise_stmt", "import_stmt", "import_name", "import_from",
"import_as_name", "dotted_as_name", "import_as_names", "dotted_as_names",
"dotted_name", "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt",
"async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt", "with_stmt",
"with_item", "except_clause", "suite", "test", "test_nocond", "lambdef",
"lambdef_nocond", "or_test", "and_test", "not_test", "comparison", "comp_op",
"star_expr", "expr", "xor_expr", "and_expr", "shift_expr", "arith_expr",
"term", "factor", "power", "atom_expr", "atom", "testlist_comp", "trailer",
"subscriptlist", "subscript", "sliceop", "exprlist", "testlist", "dictorsetmaker",
"classdef", "arglist", "argument", "comp_iter", "comp_for", "comp_if",
"encoding_decl", "yield_expr", "yield_arg"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, "'def'", "'return'", "'raise'", "'from'", "'import'",
"'as'", "'global'", "'nonlocal'", "'assert'", "'if'", "'elif'", "'else'",
"'while'", "'for'", "'in'", "'try'", "'finally'", "'with'", "'except'",
"'lambda'", "'or'", "'and'", "'not'", "'is'", "'None'", "'True'", "'False'",
"'class'", "'yield'", "'del'", "'pass'", "'continue'", "'break'", "'async'",
"'await'", null, null, null, null, null, null, null, null, null, null,
"'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'", "'**'", "'='",
"'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'",
"'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", "'<='",
"'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", "'@='", "'/='",
"'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM",
"IMPORT", "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE",
"WHILE", "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR",
"AND", "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL",
"PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL",
"BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER",
"FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN",
"CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK",
"CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT",
"ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE",
"LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1",
"NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN",
"AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN",
"LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN",
"SKIP_", "UNKNOWN_CHAR", "INDENT", "DEDENT"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Python3.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public Python3Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class Single_inputContext extends ParserRuleContext {
public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); }
public Simple_stmtContext simple_stmt() {
return getRuleContext(Simple_stmtContext.class,0);
}
public Compound_stmtContext compound_stmt() {
return getRuleContext(Compound_stmtContext.class,0);
}
public Single_inputContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_single_input; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSingle_input(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSingle_input(this);
}
}
public final Single_inputContext single_input() throws RecognitionException {
Single_inputContext _localctx = new Single_inputContext(_ctx, getState());
enterRule(_localctx, 0, RULE_single_input);
try {
setState(177);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NEWLINE:
enterOuterAlt(_localctx, 1);
{
setState(172);
match(NEWLINE);
}
break;
case STRING:
case NUMBER:
case RETURN:
case RAISE:
case FROM:
case IMPORT:
case GLOBAL:
case NONLOCAL:
case ASSERT:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case YIELD:
case DEL:
case PASS:
case CONTINUE:
case BREAK:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(173);
simple_stmt();
}
break;
case DEF:
case IF:
case WHILE:
case FOR:
case TRY:
case WITH:
case CLASS:
case ASYNC:
case AT:
enterOuterAlt(_localctx, 3);
{
setState(174);
compound_stmt();
setState(175);
match(NEWLINE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class File_inputContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(Python3Parser.EOF, 0); }
public List NEWLINE() { return getTokens(Python3Parser.NEWLINE); }
public TerminalNode NEWLINE(int i) {
return getToken(Python3Parser.NEWLINE, i);
}
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public File_inputContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_file_input; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterFile_input(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitFile_input(this);
}
}
public final File_inputContext file_input() throws RecognitionException {
File_inputContext _localctx = new File_inputContext(_ctx, getState());
enterRule(_localctx, 2, RULE_file_input);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(183);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 584344250484473334L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 32867L) != 0)) {
{
setState(181);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NEWLINE:
{
setState(179);
match(NEWLINE);
}
break;
case STRING:
case NUMBER:
case DEF:
case RETURN:
case RAISE:
case FROM:
case IMPORT:
case GLOBAL:
case NONLOCAL:
case ASSERT:
case IF:
case WHILE:
case FOR:
case TRY:
case WITH:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case CLASS:
case YIELD:
case DEL:
case PASS:
case CONTINUE:
case BREAK:
case ASYNC:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
case AT:
{
setState(180);
stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(186);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Eval_inputContext extends ParserRuleContext {
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public TerminalNode EOF() { return getToken(Python3Parser.EOF, 0); }
public List NEWLINE() { return getTokens(Python3Parser.NEWLINE); }
public TerminalNode NEWLINE(int i) {
return getToken(Python3Parser.NEWLINE, i);
}
public Eval_inputContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eval_input; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterEval_input(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitEval_input(this);
}
}
public final Eval_inputContext eval_input() throws RecognitionException {
Eval_inputContext _localctx = new Eval_inputContext(_ctx, getState());
enterRule(_localctx, 4, RULE_eval_input);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(188);
testlist();
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NEWLINE) {
{
{
setState(189);
match(NEWLINE);
}
}
setState(194);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(195);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DecoratorContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(Python3Parser.AT, 0); }
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); }
public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); }
public ArglistContext arglist() {
return getRuleContext(ArglistContext.class,0);
}
public DecoratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decorator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDecorator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDecorator(this);
}
}
public final DecoratorContext decorator() throws RecognitionException {
DecoratorContext _localctx = new DecoratorContext(_ctx, getState());
enterRule(_localctx, 6, RULE_decorator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(197);
match(AT);
setState(198);
dotted_name();
setState(204);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAREN) {
{
setState(199);
match(OPEN_PAREN);
setState(201);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 728458616071258118L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(200);
arglist();
}
}
setState(203);
match(CLOSE_PAREN);
}
}
setState(206);
match(NEWLINE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DecoratorsContext extends ParserRuleContext {
public List decorator() {
return getRuleContexts(DecoratorContext.class);
}
public DecoratorContext decorator(int i) {
return getRuleContext(DecoratorContext.class,i);
}
public DecoratorsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decorators; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDecorators(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDecorators(this);
}
}
public final DecoratorsContext decorators() throws RecognitionException {
DecoratorsContext _localctx = new DecoratorsContext(_ctx, getState());
enterRule(_localctx, 8, RULE_decorators);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(208);
decorator();
}
}
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==AT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DecoratedContext extends ParserRuleContext {
public DecoratorsContext decorators() {
return getRuleContext(DecoratorsContext.class,0);
}
public ClassdefContext classdef() {
return getRuleContext(ClassdefContext.class,0);
}
public FuncdefContext funcdef() {
return getRuleContext(FuncdefContext.class,0);
}
public Async_funcdefContext async_funcdef() {
return getRuleContext(Async_funcdefContext.class,0);
}
public DecoratedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decorated; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDecorated(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDecorated(this);
}
}
public final DecoratedContext decorated() throws RecognitionException {
DecoratedContext _localctx = new DecoratedContext(_ctx, getState());
enterRule(_localctx, 10, RULE_decorated);
try {
enterOuterAlt(_localctx, 1);
{
setState(213);
decorators();
setState(217);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLASS:
{
setState(214);
classdef();
}
break;
case DEF:
{
setState(215);
funcdef();
}
break;
case ASYNC:
{
setState(216);
async_funcdef();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Async_funcdefContext extends ParserRuleContext {
public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); }
public FuncdefContext funcdef() {
return getRuleContext(FuncdefContext.class,0);
}
public Async_funcdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_async_funcdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAsync_funcdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAsync_funcdef(this);
}
}
public final Async_funcdefContext async_funcdef() throws RecognitionException {
Async_funcdefContext _localctx = new Async_funcdefContext(_ctx, getState());
enterRule(_localctx, 12, RULE_async_funcdef);
try {
enterOuterAlt(_localctx, 1);
{
setState(219);
match(ASYNC);
setState(220);
funcdef();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FuncdefContext extends ParserRuleContext {
public TerminalNode DEF() { return getToken(Python3Parser.DEF, 0); }
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public TerminalNode ARROW() { return getToken(Python3Parser.ARROW, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public FuncdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterFuncdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitFuncdef(this);
}
}
public final FuncdefContext funcdef() throws RecognitionException {
FuncdefContext _localctx = new FuncdefContext(_ctx, getState());
enterRule(_localctx, 14, RULE_funcdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(222);
match(DEF);
setState(223);
match(NAME);
setState(224);
parameters();
setState(227);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ARROW) {
{
setState(225);
match(ARROW);
setState(226);
test();
}
}
setState(229);
match(COLON);
setState(230);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParametersContext extends ParserRuleContext {
public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); }
public TypedargslistContext typedargslist() {
return getRuleContext(TypedargslistContext.class,0);
}
public ParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitParameters(this);
}
}
public final ParametersContext parameters() throws RecognitionException {
ParametersContext _localctx = new ParametersContext(_ctx, getState());
enterRule(_localctx, 16, RULE_parameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(232);
match(OPEN_PAREN);
setState(234);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 146368087401168896L) != 0)) {
{
setState(233);
typedargslist();
}
}
setState(236);
match(CLOSE_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypedargslistContext extends ParserRuleContext {
public List tfpdef() {
return getRuleContexts(TfpdefContext.class);
}
public TfpdefContext tfpdef(int i) {
return getRuleContext(TfpdefContext.class,i);
}
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); }
public List ASSIGN() { return getTokens(Python3Parser.ASSIGN); }
public TerminalNode ASSIGN(int i) {
return getToken(Python3Parser.ASSIGN, i);
}
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public TypedargslistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typedargslist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTypedargslist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTypedargslist(this);
}
}
public final TypedargslistContext typedargslist() throws RecognitionException {
TypedargslistContext _localctx = new TypedargslistContext(_ctx, getState());
enterRule(_localctx, 18, RULE_typedargslist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(319);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NAME:
{
setState(238);
tfpdef();
setState(241);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(239);
match(ASSIGN);
setState(240);
test();
}
}
setState(251);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(243);
match(COMMA);
setState(244);
tfpdef();
setState(247);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(245);
match(ASSIGN);
setState(246);
test();
}
}
}
}
}
setState(253);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
setState(287);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(254);
match(COMMA);
setState(285);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(255);
match(STAR);
setState(257);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(256);
tfpdef();
}
}
setState(267);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(259);
match(COMMA);
setState(260);
tfpdef();
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(261);
match(ASSIGN);
setState(262);
test();
}
}
}
}
}
setState(269);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,15,_ctx);
}
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(270);
match(COMMA);
setState(276);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(271);
match(POWER);
setState(272);
tfpdef();
setState(274);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(273);
match(COMMA);
}
}
}
}
}
}
}
break;
case POWER:
{
setState(280);
match(POWER);
setState(281);
tfpdef();
setState(283);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(282);
match(COMMA);
}
}
}
break;
case CLOSE_PAREN:
break;
default:
break;
}
}
}
}
break;
case STAR:
{
setState(289);
match(STAR);
setState(291);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(290);
tfpdef();
}
}
setState(301);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(293);
match(COMMA);
setState(294);
tfpdef();
setState(297);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(295);
match(ASSIGN);
setState(296);
test();
}
}
}
}
}
setState(303);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(304);
match(COMMA);
setState(310);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(305);
match(POWER);
setState(306);
tfpdef();
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(307);
match(COMMA);
}
}
}
}
}
}
}
break;
case POWER:
{
setState(314);
match(POWER);
setState(315);
tfpdef();
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(316);
match(COMMA);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TfpdefContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public TfpdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tfpdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTfpdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTfpdef(this);
}
}
public final TfpdefContext tfpdef() throws RecognitionException {
TfpdefContext _localctx = new TfpdefContext(_ctx, getState());
enterRule(_localctx, 20, RULE_tfpdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(321);
match(NAME);
setState(324);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(322);
match(COLON);
setState(323);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VarargslistContext extends ParserRuleContext {
public List vfpdef() {
return getRuleContexts(VfpdefContext.class);
}
public VfpdefContext vfpdef(int i) {
return getRuleContext(VfpdefContext.class,i);
}
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); }
public List ASSIGN() { return getTokens(Python3Parser.ASSIGN); }
public TerminalNode ASSIGN(int i) {
return getToken(Python3Parser.ASSIGN, i);
}
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public VarargslistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varargslist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterVarargslist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitVarargslist(this);
}
}
public final VarargslistContext varargslist() throws RecognitionException {
VarargslistContext _localctx = new VarargslistContext(_ctx, getState());
enterRule(_localctx, 22, RULE_varargslist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(407);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NAME:
{
setState(326);
vfpdef();
setState(329);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(327);
match(ASSIGN);
setState(328);
test();
}
}
setState(339);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(331);
match(COMMA);
setState(332);
vfpdef();
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(333);
match(ASSIGN);
setState(334);
test();
}
}
}
}
}
setState(341);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
setState(375);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(342);
match(COMMA);
setState(373);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(343);
match(STAR);
setState(345);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(344);
vfpdef();
}
}
setState(355);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(347);
match(COMMA);
setState(348);
vfpdef();
setState(351);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(349);
match(ASSIGN);
setState(350);
test();
}
}
}
}
}
setState(357);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
}
setState(366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(358);
match(COMMA);
setState(364);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(359);
match(POWER);
setState(360);
vfpdef();
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(361);
match(COMMA);
}
}
}
}
}
}
}
break;
case POWER:
{
setState(368);
match(POWER);
setState(369);
vfpdef();
setState(371);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(370);
match(COMMA);
}
}
}
break;
case COLON:
break;
default:
break;
}
}
}
}
break;
case STAR:
{
setState(377);
match(STAR);
setState(379);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(378);
vfpdef();
}
}
setState(389);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(381);
match(COMMA);
setState(382);
vfpdef();
setState(385);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(383);
match(ASSIGN);
setState(384);
test();
}
}
}
}
}
setState(391);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(392);
match(COMMA);
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(393);
match(POWER);
setState(394);
vfpdef();
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(395);
match(COMMA);
}
}
}
}
}
}
}
break;
case POWER:
{
setState(402);
match(POWER);
setState(403);
vfpdef();
setState(405);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(404);
match(COMMA);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VfpdefContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public VfpdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vfpdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterVfpdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitVfpdef(this);
}
}
public final VfpdefContext vfpdef() throws RecognitionException {
VfpdefContext _localctx = new VfpdefContext(_ctx, getState());
enterRule(_localctx, 24, RULE_vfpdef);
try {
enterOuterAlt(_localctx, 1);
{
setState(409);
match(NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StmtContext extends ParserRuleContext {
public Simple_stmtContext simple_stmt() {
return getRuleContext(Simple_stmtContext.class,0);
}
public Compound_stmtContext compound_stmt() {
return getRuleContext(Compound_stmtContext.class,0);
}
public StmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitStmt(this);
}
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 26, RULE_stmt);
try {
setState(413);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case RETURN:
case RAISE:
case FROM:
case IMPORT:
case GLOBAL:
case NONLOCAL:
case ASSERT:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case YIELD:
case DEL:
case PASS:
case CONTINUE:
case BREAK:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(411);
simple_stmt();
}
break;
case DEF:
case IF:
case WHILE:
case FOR:
case TRY:
case WITH:
case CLASS:
case ASYNC:
case AT:
enterOuterAlt(_localctx, 2);
{
setState(412);
compound_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Simple_stmtContext extends ParserRuleContext {
public List small_stmt() {
return getRuleContexts(Small_stmtContext.class);
}
public Small_stmtContext small_stmt(int i) {
return getRuleContext(Small_stmtContext.class,i);
}
public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); }
public List SEMI_COLON() { return getTokens(Python3Parser.SEMI_COLON); }
public TerminalNode SEMI_COLON(int i) {
return getToken(Python3Parser.SEMI_COLON, i);
}
public Simple_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSimple_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSimple_stmt(this);
}
}
public final Simple_stmtContext simple_stmt() throws RecognitionException {
Simple_stmtContext _localctx = new Simple_stmtContext(_ctx, getState());
enterRule(_localctx, 28, RULE_simple_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(415);
small_stmt();
setState(420);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(416);
match(SEMI_COLON);
setState(417);
small_stmt();
}
}
}
setState(422);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
}
setState(424);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI_COLON) {
{
setState(423);
match(SEMI_COLON);
}
}
setState(426);
match(NEWLINE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Small_stmtContext extends ParserRuleContext {
public Expr_stmtContext expr_stmt() {
return getRuleContext(Expr_stmtContext.class,0);
}
public Del_stmtContext del_stmt() {
return getRuleContext(Del_stmtContext.class,0);
}
public Pass_stmtContext pass_stmt() {
return getRuleContext(Pass_stmtContext.class,0);
}
public Flow_stmtContext flow_stmt() {
return getRuleContext(Flow_stmtContext.class,0);
}
public Import_stmtContext import_stmt() {
return getRuleContext(Import_stmtContext.class,0);
}
public Global_stmtContext global_stmt() {
return getRuleContext(Global_stmtContext.class,0);
}
public Nonlocal_stmtContext nonlocal_stmt() {
return getRuleContext(Nonlocal_stmtContext.class,0);
}
public Assert_stmtContext assert_stmt() {
return getRuleContext(Assert_stmtContext.class,0);
}
public Small_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_small_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSmall_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSmall_stmt(this);
}
}
public final Small_stmtContext small_stmt() throws RecognitionException {
Small_stmtContext _localctx = new Small_stmtContext(_ctx, getState());
enterRule(_localctx, 30, RULE_small_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(436);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(428);
expr_stmt();
}
break;
case DEL:
{
setState(429);
del_stmt();
}
break;
case PASS:
{
setState(430);
pass_stmt();
}
break;
case RETURN:
case RAISE:
case YIELD:
case CONTINUE:
case BREAK:
{
setState(431);
flow_stmt();
}
break;
case FROM:
case IMPORT:
{
setState(432);
import_stmt();
}
break;
case GLOBAL:
{
setState(433);
global_stmt();
}
break;
case NONLOCAL:
{
setState(434);
nonlocal_stmt();
}
break;
case ASSERT:
{
setState(435);
assert_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Expr_stmtContext extends ParserRuleContext {
public List testlist_star_expr() {
return getRuleContexts(Testlist_star_exprContext.class);
}
public Testlist_star_exprContext testlist_star_expr(int i) {
return getRuleContext(Testlist_star_exprContext.class,i);
}
public AnnassignContext annassign() {
return getRuleContext(AnnassignContext.class,0);
}
public AugassignContext augassign() {
return getRuleContext(AugassignContext.class,0);
}
public List yield_expr() {
return getRuleContexts(Yield_exprContext.class);
}
public Yield_exprContext yield_expr(int i) {
return getRuleContext(Yield_exprContext.class,i);
}
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public List ASSIGN() { return getTokens(Python3Parser.ASSIGN); }
public TerminalNode ASSIGN(int i) {
return getToken(Python3Parser.ASSIGN, i);
}
public Expr_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterExpr_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitExpr_stmt(this);
}
}
public final Expr_stmtContext expr_stmt() throws RecognitionException {
Expr_stmtContext _localctx = new Expr_stmtContext(_ctx, getState());
enterRule(_localctx, 32, RULE_expr_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(438);
testlist_star_expr();
setState(455);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
{
setState(439);
annassign();
}
break;
case ADD_ASSIGN:
case SUB_ASSIGN:
case MULT_ASSIGN:
case AT_ASSIGN:
case DIV_ASSIGN:
case MOD_ASSIGN:
case AND_ASSIGN:
case OR_ASSIGN:
case XOR_ASSIGN:
case LEFT_SHIFT_ASSIGN:
case RIGHT_SHIFT_ASSIGN:
case POWER_ASSIGN:
case IDIV_ASSIGN:
{
setState(440);
augassign();
setState(443);
_errHandler.sync(this);
switch (_input.LA(1)) {
case YIELD:
{
setState(441);
yield_expr();
}
break;
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(442);
testlist();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case NEWLINE:
case SEMI_COLON:
case ASSIGN:
{
setState(452);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ASSIGN) {
{
{
setState(445);
match(ASSIGN);
setState(448);
_errHandler.sync(this);
switch (_input.LA(1)) {
case YIELD:
{
setState(446);
yield_expr();
}
break;
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(447);
testlist_star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(454);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnnassignContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public TerminalNode ASSIGN() { return getToken(Python3Parser.ASSIGN, 0); }
public AnnassignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annassign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAnnassign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAnnassign(this);
}
}
public final AnnassignContext annassign() throws RecognitionException {
AnnassignContext _localctx = new AnnassignContext(_ctx, getState());
enterRule(_localctx, 34, RULE_annassign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(457);
match(COLON);
setState(458);
test();
setState(461);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(459);
match(ASSIGN);
setState(460);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Testlist_star_exprContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List star_expr() {
return getRuleContexts(Star_exprContext.class);
}
public Star_exprContext star_expr(int i) {
return getRuleContext(Star_exprContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public Testlist_star_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist_star_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTestlist_star_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTestlist_star_expr(this);
}
}
public final Testlist_star_exprContext testlist_star_expr() throws RecognitionException {
Testlist_star_exprContext _localctx = new Testlist_star_exprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_testlist_star_expr);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(465);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(463);
test();
}
break;
case STAR:
{
setState(464);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(474);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(467);
match(COMMA);
setState(470);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(468);
test();
}
break;
case STAR:
{
setState(469);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
setState(476);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
}
setState(478);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(477);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AugassignContext extends ParserRuleContext {
public TerminalNode ADD_ASSIGN() { return getToken(Python3Parser.ADD_ASSIGN, 0); }
public TerminalNode SUB_ASSIGN() { return getToken(Python3Parser.SUB_ASSIGN, 0); }
public TerminalNode MULT_ASSIGN() { return getToken(Python3Parser.MULT_ASSIGN, 0); }
public TerminalNode AT_ASSIGN() { return getToken(Python3Parser.AT_ASSIGN, 0); }
public TerminalNode DIV_ASSIGN() { return getToken(Python3Parser.DIV_ASSIGN, 0); }
public TerminalNode MOD_ASSIGN() { return getToken(Python3Parser.MOD_ASSIGN, 0); }
public TerminalNode AND_ASSIGN() { return getToken(Python3Parser.AND_ASSIGN, 0); }
public TerminalNode OR_ASSIGN() { return getToken(Python3Parser.OR_ASSIGN, 0); }
public TerminalNode XOR_ASSIGN() { return getToken(Python3Parser.XOR_ASSIGN, 0); }
public TerminalNode LEFT_SHIFT_ASSIGN() { return getToken(Python3Parser.LEFT_SHIFT_ASSIGN, 0); }
public TerminalNode RIGHT_SHIFT_ASSIGN() { return getToken(Python3Parser.RIGHT_SHIFT_ASSIGN, 0); }
public TerminalNode POWER_ASSIGN() { return getToken(Python3Parser.POWER_ASSIGN, 0); }
public TerminalNode IDIV_ASSIGN() { return getToken(Python3Parser.IDIV_ASSIGN, 0); }
public AugassignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_augassign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAugassign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAugassign(this);
}
}
public final AugassignContext augassign() throws RecognitionException {
AugassignContext _localctx = new AugassignContext(_ctx, getState());
enterRule(_localctx, 38, RULE_augassign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(480);
_la = _input.LA(1);
if ( !(((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & 8191L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Del_stmtContext extends ParserRuleContext {
public TerminalNode DEL() { return getToken(Python3Parser.DEL, 0); }
public ExprlistContext exprlist() {
return getRuleContext(ExprlistContext.class,0);
}
public Del_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_del_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDel_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDel_stmt(this);
}
}
public final Del_stmtContext del_stmt() throws RecognitionException {
Del_stmtContext _localctx = new Del_stmtContext(_ctx, getState());
enterRule(_localctx, 40, RULE_del_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(482);
match(DEL);
setState(483);
exprlist();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Pass_stmtContext extends ParserRuleContext {
public TerminalNode PASS() { return getToken(Python3Parser.PASS, 0); }
public Pass_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pass_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterPass_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitPass_stmt(this);
}
}
public final Pass_stmtContext pass_stmt() throws RecognitionException {
Pass_stmtContext _localctx = new Pass_stmtContext(_ctx, getState());
enterRule(_localctx, 42, RULE_pass_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(485);
match(PASS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Flow_stmtContext extends ParserRuleContext {
public Break_stmtContext break_stmt() {
return getRuleContext(Break_stmtContext.class,0);
}
public Continue_stmtContext continue_stmt() {
return getRuleContext(Continue_stmtContext.class,0);
}
public Return_stmtContext return_stmt() {
return getRuleContext(Return_stmtContext.class,0);
}
public Raise_stmtContext raise_stmt() {
return getRuleContext(Raise_stmtContext.class,0);
}
public Yield_stmtContext yield_stmt() {
return getRuleContext(Yield_stmtContext.class,0);
}
public Flow_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_flow_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterFlow_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitFlow_stmt(this);
}
}
public final Flow_stmtContext flow_stmt() throws RecognitionException {
Flow_stmtContext _localctx = new Flow_stmtContext(_ctx, getState());
enterRule(_localctx, 44, RULE_flow_stmt);
try {
setState(492);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BREAK:
enterOuterAlt(_localctx, 1);
{
setState(487);
break_stmt();
}
break;
case CONTINUE:
enterOuterAlt(_localctx, 2);
{
setState(488);
continue_stmt();
}
break;
case RETURN:
enterOuterAlt(_localctx, 3);
{
setState(489);
return_stmt();
}
break;
case RAISE:
enterOuterAlt(_localctx, 4);
{
setState(490);
raise_stmt();
}
break;
case YIELD:
enterOuterAlt(_localctx, 5);
{
setState(491);
yield_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Break_stmtContext extends ParserRuleContext {
public TerminalNode BREAK() { return getToken(Python3Parser.BREAK, 0); }
public Break_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_break_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterBreak_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitBreak_stmt(this);
}
}
public final Break_stmtContext break_stmt() throws RecognitionException {
Break_stmtContext _localctx = new Break_stmtContext(_ctx, getState());
enterRule(_localctx, 46, RULE_break_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(494);
match(BREAK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Continue_stmtContext extends ParserRuleContext {
public TerminalNode CONTINUE() { return getToken(Python3Parser.CONTINUE, 0); }
public Continue_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continue_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterContinue_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitContinue_stmt(this);
}
}
public final Continue_stmtContext continue_stmt() throws RecognitionException {
Continue_stmtContext _localctx = new Continue_stmtContext(_ctx, getState());
enterRule(_localctx, 48, RULE_continue_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(496);
match(CONTINUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Return_stmtContext extends ParserRuleContext {
public TerminalNode RETURN() { return getToken(Python3Parser.RETURN, 0); }
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public Return_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_return_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterReturn_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitReturn_stmt(this);
}
}
public final Return_stmtContext return_stmt() throws RecognitionException {
Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState());
enterRule(_localctx, 50, RULE_return_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(498);
match(RETURN);
setState(500);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181716998L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(499);
testlist();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Yield_stmtContext extends ParserRuleContext {
public Yield_exprContext yield_expr() {
return getRuleContext(Yield_exprContext.class,0);
}
public Yield_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_yield_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterYield_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitYield_stmt(this);
}
}
public final Yield_stmtContext yield_stmt() throws RecognitionException {
Yield_stmtContext _localctx = new Yield_stmtContext(_ctx, getState());
enterRule(_localctx, 52, RULE_yield_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(502);
yield_expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Raise_stmtContext extends ParserRuleContext {
public TerminalNode RAISE() { return getToken(Python3Parser.RAISE, 0); }
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public TerminalNode FROM() { return getToken(Python3Parser.FROM, 0); }
public Raise_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_raise_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterRaise_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitRaise_stmt(this);
}
}
public final Raise_stmtContext raise_stmt() throws RecognitionException {
Raise_stmtContext _localctx = new Raise_stmtContext(_ctx, getState());
enterRule(_localctx, 54, RULE_raise_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(504);
match(RAISE);
setState(510);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181716998L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(505);
test();
setState(508);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(506);
match(FROM);
setState(507);
test();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Import_stmtContext extends ParserRuleContext {
public Import_nameContext import_name() {
return getRuleContext(Import_nameContext.class,0);
}
public Import_fromContext import_from() {
return getRuleContext(Import_fromContext.class,0);
}
public Import_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterImport_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitImport_stmt(this);
}
}
public final Import_stmtContext import_stmt() throws RecognitionException {
Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState());
enterRule(_localctx, 56, RULE_import_stmt);
try {
setState(514);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IMPORT:
enterOuterAlt(_localctx, 1);
{
setState(512);
import_name();
}
break;
case FROM:
enterOuterAlt(_localctx, 2);
{
setState(513);
import_from();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Import_nameContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(Python3Parser.IMPORT, 0); }
public Dotted_as_namesContext dotted_as_names() {
return getRuleContext(Dotted_as_namesContext.class,0);
}
public Import_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterImport_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitImport_name(this);
}
}
public final Import_nameContext import_name() throws RecognitionException {
Import_nameContext _localctx = new Import_nameContext(_ctx, getState());
enterRule(_localctx, 58, RULE_import_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(516);
match(IMPORT);
setState(517);
dotted_as_names();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Import_fromContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(Python3Parser.FROM, 0); }
public TerminalNode IMPORT() { return getToken(Python3Parser.IMPORT, 0); }
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); }
public Import_as_namesContext import_as_names() {
return getRuleContext(Import_as_namesContext.class,0);
}
public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); }
public List DOT() { return getTokens(Python3Parser.DOT); }
public TerminalNode DOT(int i) {
return getToken(Python3Parser.DOT, i);
}
public List ELLIPSIS() { return getTokens(Python3Parser.ELLIPSIS); }
public TerminalNode ELLIPSIS(int i) {
return getToken(Python3Parser.ELLIPSIS, i);
}
public Import_fromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_from; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterImport_from(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitImport_from(this);
}
}
public final Import_fromContext import_from() throws RecognitionException {
Import_fromContext _localctx = new Import_fromContext(_ctx, getState());
enterRule(_localctx, 60, RULE_import_from);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(519);
match(FROM);
setState(532);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
{
setState(523);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==ELLIPSIS) {
{
{
setState(520);
_la = _input.LA(1);
if ( !(_la==DOT || _la==ELLIPSIS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(525);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(526);
dotted_name();
}
break;
case 2:
{
setState(528);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(527);
_la = _input.LA(1);
if ( !(_la==DOT || _la==ELLIPSIS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DOT || _la==ELLIPSIS );
}
break;
}
setState(534);
match(IMPORT);
setState(541);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(535);
match(STAR);
}
break;
case OPEN_PAREN:
{
setState(536);
match(OPEN_PAREN);
setState(537);
import_as_names();
setState(538);
match(CLOSE_PAREN);
}
break;
case NAME:
{
setState(540);
import_as_names();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Import_as_nameContext extends ParserRuleContext {
public List NAME() { return getTokens(Python3Parser.NAME); }
public TerminalNode NAME(int i) {
return getToken(Python3Parser.NAME, i);
}
public TerminalNode AS() { return getToken(Python3Parser.AS, 0); }
public Import_as_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_as_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterImport_as_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitImport_as_name(this);
}
}
public final Import_as_nameContext import_as_name() throws RecognitionException {
Import_as_nameContext _localctx = new Import_as_nameContext(_ctx, getState());
enterRule(_localctx, 62, RULE_import_as_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(543);
match(NAME);
setState(546);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(544);
match(AS);
setState(545);
match(NAME);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dotted_as_nameContext extends ParserRuleContext {
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode AS() { return getToken(Python3Parser.AS, 0); }
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public Dotted_as_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_as_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDotted_as_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDotted_as_name(this);
}
}
public final Dotted_as_nameContext dotted_as_name() throws RecognitionException {
Dotted_as_nameContext _localctx = new Dotted_as_nameContext(_ctx, getState());
enterRule(_localctx, 64, RULE_dotted_as_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(548);
dotted_name();
setState(551);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(549);
match(AS);
setState(550);
match(NAME);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Import_as_namesContext extends ParserRuleContext {
public List import_as_name() {
return getRuleContexts(Import_as_nameContext.class);
}
public Import_as_nameContext import_as_name(int i) {
return getRuleContext(Import_as_nameContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public Import_as_namesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_as_names; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterImport_as_names(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitImport_as_names(this);
}
}
public final Import_as_namesContext import_as_names() throws RecognitionException {
Import_as_namesContext _localctx = new Import_as_namesContext(_ctx, getState());
enterRule(_localctx, 66, RULE_import_as_names);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(553);
import_as_name();
setState(558);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(554);
match(COMMA);
setState(555);
import_as_name();
}
}
}
setState(560);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
}
setState(562);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(561);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dotted_as_namesContext extends ParserRuleContext {
public List dotted_as_name() {
return getRuleContexts(Dotted_as_nameContext.class);
}
public Dotted_as_nameContext dotted_as_name(int i) {
return getRuleContext(Dotted_as_nameContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public Dotted_as_namesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_as_names; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDotted_as_names(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDotted_as_names(this);
}
}
public final Dotted_as_namesContext dotted_as_names() throws RecognitionException {
Dotted_as_namesContext _localctx = new Dotted_as_namesContext(_ctx, getState());
enterRule(_localctx, 68, RULE_dotted_as_names);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(564);
dotted_as_name();
setState(569);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(565);
match(COMMA);
setState(566);
dotted_as_name();
}
}
setState(571);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Dotted_nameContext extends ParserRuleContext {
public List NAME() { return getTokens(Python3Parser.NAME); }
public TerminalNode NAME(int i) {
return getToken(Python3Parser.NAME, i);
}
public List DOT() { return getTokens(Python3Parser.DOT); }
public TerminalNode DOT(int i) {
return getToken(Python3Parser.DOT, i);
}
public Dotted_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDotted_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDotted_name(this);
}
}
public final Dotted_nameContext dotted_name() throws RecognitionException {
Dotted_nameContext _localctx = new Dotted_nameContext(_ctx, getState());
enterRule(_localctx, 70, RULE_dotted_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(572);
match(NAME);
setState(577);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(573);
match(DOT);
setState(574);
match(NAME);
}
}
setState(579);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Global_stmtContext extends ParserRuleContext {
public TerminalNode GLOBAL() { return getToken(Python3Parser.GLOBAL, 0); }
public List NAME() { return getTokens(Python3Parser.NAME); }
public TerminalNode NAME(int i) {
return getToken(Python3Parser.NAME, i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public Global_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_global_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterGlobal_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitGlobal_stmt(this);
}
}
public final Global_stmtContext global_stmt() throws RecognitionException {
Global_stmtContext _localctx = new Global_stmtContext(_ctx, getState());
enterRule(_localctx, 72, RULE_global_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(580);
match(GLOBAL);
setState(581);
match(NAME);
setState(586);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(582);
match(COMMA);
setState(583);
match(NAME);
}
}
setState(588);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Nonlocal_stmtContext extends ParserRuleContext {
public TerminalNode NONLOCAL() { return getToken(Python3Parser.NONLOCAL, 0); }
public List NAME() { return getTokens(Python3Parser.NAME); }
public TerminalNode NAME(int i) {
return getToken(Python3Parser.NAME, i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public Nonlocal_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonlocal_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterNonlocal_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitNonlocal_stmt(this);
}
}
public final Nonlocal_stmtContext nonlocal_stmt() throws RecognitionException {
Nonlocal_stmtContext _localctx = new Nonlocal_stmtContext(_ctx, getState());
enterRule(_localctx, 74, RULE_nonlocal_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(589);
match(NONLOCAL);
setState(590);
match(NAME);
setState(595);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(591);
match(COMMA);
setState(592);
match(NAME);
}
}
setState(597);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Assert_stmtContext extends ParserRuleContext {
public TerminalNode ASSERT() { return getToken(Python3Parser.ASSERT, 0); }
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public TerminalNode COMMA() { return getToken(Python3Parser.COMMA, 0); }
public Assert_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assert_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAssert_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAssert_stmt(this);
}
}
public final Assert_stmtContext assert_stmt() throws RecognitionException {
Assert_stmtContext _localctx = new Assert_stmtContext(_ctx, getState());
enterRule(_localctx, 76, RULE_assert_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(598);
match(ASSERT);
setState(599);
test();
setState(602);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(600);
match(COMMA);
setState(601);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Compound_stmtContext extends ParserRuleContext {
public If_stmtContext if_stmt() {
return getRuleContext(If_stmtContext.class,0);
}
public While_stmtContext while_stmt() {
return getRuleContext(While_stmtContext.class,0);
}
public For_stmtContext for_stmt() {
return getRuleContext(For_stmtContext.class,0);
}
public Try_stmtContext try_stmt() {
return getRuleContext(Try_stmtContext.class,0);
}
public With_stmtContext with_stmt() {
return getRuleContext(With_stmtContext.class,0);
}
public FuncdefContext funcdef() {
return getRuleContext(FuncdefContext.class,0);
}
public ClassdefContext classdef() {
return getRuleContext(ClassdefContext.class,0);
}
public DecoratedContext decorated() {
return getRuleContext(DecoratedContext.class,0);
}
public Async_stmtContext async_stmt() {
return getRuleContext(Async_stmtContext.class,0);
}
public Compound_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compound_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterCompound_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitCompound_stmt(this);
}
}
public final Compound_stmtContext compound_stmt() throws RecognitionException {
Compound_stmtContext _localctx = new Compound_stmtContext(_ctx, getState());
enterRule(_localctx, 78, RULE_compound_stmt);
try {
setState(613);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IF:
enterOuterAlt(_localctx, 1);
{
setState(604);
if_stmt();
}
break;
case WHILE:
enterOuterAlt(_localctx, 2);
{
setState(605);
while_stmt();
}
break;
case FOR:
enterOuterAlt(_localctx, 3);
{
setState(606);
for_stmt();
}
break;
case TRY:
enterOuterAlt(_localctx, 4);
{
setState(607);
try_stmt();
}
break;
case WITH:
enterOuterAlt(_localctx, 5);
{
setState(608);
with_stmt();
}
break;
case DEF:
enterOuterAlt(_localctx, 6);
{
setState(609);
funcdef();
}
break;
case CLASS:
enterOuterAlt(_localctx, 7);
{
setState(610);
classdef();
}
break;
case AT:
enterOuterAlt(_localctx, 8);
{
setState(611);
decorated();
}
break;
case ASYNC:
enterOuterAlt(_localctx, 9);
{
setState(612);
async_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Async_stmtContext extends ParserRuleContext {
public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); }
public FuncdefContext funcdef() {
return getRuleContext(FuncdefContext.class,0);
}
public With_stmtContext with_stmt() {
return getRuleContext(With_stmtContext.class,0);
}
public For_stmtContext for_stmt() {
return getRuleContext(For_stmtContext.class,0);
}
public Async_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_async_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAsync_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAsync_stmt(this);
}
}
public final Async_stmtContext async_stmt() throws RecognitionException {
Async_stmtContext _localctx = new Async_stmtContext(_ctx, getState());
enterRule(_localctx, 80, RULE_async_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(615);
match(ASYNC);
setState(619);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEF:
{
setState(616);
funcdef();
}
break;
case WITH:
{
setState(617);
with_stmt();
}
break;
case FOR:
{
setState(618);
for_stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class If_stmtContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(Python3Parser.IF, 0); }
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COLON() { return getTokens(Python3Parser.COLON); }
public TerminalNode COLON(int i) {
return getToken(Python3Parser.COLON, i);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public List ELIF() { return getTokens(Python3Parser.ELIF); }
public TerminalNode ELIF(int i) {
return getToken(Python3Parser.ELIF, i);
}
public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); }
public If_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_if_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterIf_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitIf_stmt(this);
}
}
public final If_stmtContext if_stmt() throws RecognitionException {
If_stmtContext _localctx = new If_stmtContext(_ctx, getState());
enterRule(_localctx, 82, RULE_if_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(621);
match(IF);
setState(622);
test();
setState(623);
match(COLON);
setState(624);
suite();
setState(632);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ELIF) {
{
{
setState(625);
match(ELIF);
setState(626);
test();
setState(627);
match(COLON);
setState(628);
suite();
}
}
setState(634);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(638);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(635);
match(ELSE);
setState(636);
match(COLON);
setState(637);
suite();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class While_stmtContext extends ParserRuleContext {
public TerminalNode WHILE() { return getToken(Python3Parser.WHILE, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public List COLON() { return getTokens(Python3Parser.COLON); }
public TerminalNode COLON(int i) {
return getToken(Python3Parser.COLON, i);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); }
public While_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_while_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterWhile_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitWhile_stmt(this);
}
}
public final While_stmtContext while_stmt() throws RecognitionException {
While_stmtContext _localctx = new While_stmtContext(_ctx, getState());
enterRule(_localctx, 84, RULE_while_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(640);
match(WHILE);
setState(641);
test();
setState(642);
match(COLON);
setState(643);
suite();
setState(647);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(644);
match(ELSE);
setState(645);
match(COLON);
setState(646);
suite();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class For_stmtContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(Python3Parser.FOR, 0); }
public ExprlistContext exprlist() {
return getRuleContext(ExprlistContext.class,0);
}
public TerminalNode IN() { return getToken(Python3Parser.IN, 0); }
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public List COLON() { return getTokens(Python3Parser.COLON); }
public TerminalNode COLON(int i) {
return getToken(Python3Parser.COLON, i);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); }
public For_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_for_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterFor_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitFor_stmt(this);
}
}
public final For_stmtContext for_stmt() throws RecognitionException {
For_stmtContext _localctx = new For_stmtContext(_ctx, getState());
enterRule(_localctx, 86, RULE_for_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(649);
match(FOR);
setState(650);
exprlist();
setState(651);
match(IN);
setState(652);
testlist();
setState(653);
match(COLON);
setState(654);
suite();
setState(658);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(655);
match(ELSE);
setState(656);
match(COLON);
setState(657);
suite();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Try_stmtContext extends ParserRuleContext {
public TerminalNode TRY() { return getToken(Python3Parser.TRY, 0); }
public List COLON() { return getTokens(Python3Parser.COLON); }
public TerminalNode COLON(int i) {
return getToken(Python3Parser.COLON, i);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public TerminalNode FINALLY() { return getToken(Python3Parser.FINALLY, 0); }
public List except_clause() {
return getRuleContexts(Except_clauseContext.class);
}
public Except_clauseContext except_clause(int i) {
return getRuleContext(Except_clauseContext.class,i);
}
public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); }
public Try_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_try_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTry_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTry_stmt(this);
}
}
public final Try_stmtContext try_stmt() throws RecognitionException {
Try_stmtContext _localctx = new Try_stmtContext(_ctx, getState());
enterRule(_localctx, 88, RULE_try_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(660);
match(TRY);
setState(661);
match(COLON);
setState(662);
suite();
setState(684);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EXCEPT:
{
setState(667);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(663);
except_clause();
setState(664);
match(COLON);
setState(665);
suite();
}
}
setState(669);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==EXCEPT );
setState(674);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(671);
match(ELSE);
setState(672);
match(COLON);
setState(673);
suite();
}
}
setState(679);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(676);
match(FINALLY);
setState(677);
match(COLON);
setState(678);
suite();
}
}
}
break;
case FINALLY:
{
setState(681);
match(FINALLY);
setState(682);
match(COLON);
setState(683);
suite();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class With_stmtContext extends ParserRuleContext {
public TerminalNode WITH() { return getToken(Python3Parser.WITH, 0); }
public List with_item() {
return getRuleContexts(With_itemContext.class);
}
public With_itemContext with_item(int i) {
return getRuleContext(With_itemContext.class,i);
}
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public With_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterWith_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitWith_stmt(this);
}
}
public final With_stmtContext with_stmt() throws RecognitionException {
With_stmtContext _localctx = new With_stmtContext(_ctx, getState());
enterRule(_localctx, 90, RULE_with_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(686);
match(WITH);
setState(687);
with_item();
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(688);
match(COMMA);
setState(689);
with_item();
}
}
setState(694);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(695);
match(COLON);
setState(696);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class With_itemContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public TerminalNode AS() { return getToken(Python3Parser.AS, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public With_itemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterWith_item(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitWith_item(this);
}
}
public final With_itemContext with_item() throws RecognitionException {
With_itemContext _localctx = new With_itemContext(_ctx, getState());
enterRule(_localctx, 92, RULE_with_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(698);
test();
setState(701);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(699);
match(AS);
setState(700);
expr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Except_clauseContext extends ParserRuleContext {
public TerminalNode EXCEPT() { return getToken(Python3Parser.EXCEPT, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public TerminalNode AS() { return getToken(Python3Parser.AS, 0); }
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public Except_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_except_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterExcept_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitExcept_clause(this);
}
}
public final Except_clauseContext except_clause() throws RecognitionException {
Except_clauseContext _localctx = new Except_clauseContext(_ctx, getState());
enterRule(_localctx, 94, RULE_except_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(703);
match(EXCEPT);
setState(709);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181716998L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(704);
test();
setState(707);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(705);
match(AS);
setState(706);
match(NAME);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SuiteContext extends ParserRuleContext {
public Simple_stmtContext simple_stmt() {
return getRuleContext(Simple_stmtContext.class,0);
}
public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); }
public TerminalNode INDENT() { return getToken(Python3Parser.INDENT, 0); }
public TerminalNode DEDENT() { return getToken(Python3Parser.DEDENT, 0); }
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public SuiteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_suite; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSuite(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSuite(this);
}
}
public final SuiteContext suite() throws RecognitionException {
SuiteContext _localctx = new SuiteContext(_ctx, getState());
enterRule(_localctx, 96, RULE_suite);
int _la;
try {
setState(721);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case RETURN:
case RAISE:
case FROM:
case IMPORT:
case GLOBAL:
case NONLOCAL:
case ASSERT:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case YIELD:
case DEL:
case PASS:
case CONTINUE:
case BREAK:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(711);
simple_stmt();
}
break;
case NEWLINE:
enterOuterAlt(_localctx, 2);
{
setState(712);
match(NEWLINE);
setState(713);
match(INDENT);
setState(715);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(714);
stmt();
}
}
setState(717);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 584343700728659446L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 32867L) != 0) );
setState(719);
match(DEDENT);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TestContext extends ParserRuleContext {
public List or_test() {
return getRuleContexts(Or_testContext.class);
}
public Or_testContext or_test(int i) {
return getRuleContext(Or_testContext.class,i);
}
public TerminalNode IF() { return getToken(Python3Parser.IF, 0); }
public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public LambdefContext lambdef() {
return getRuleContext(LambdefContext.class,0);
}
public TestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTest(this);
}
}
public final TestContext test() throws RecognitionException {
TestContext _localctx = new TestContext(_ctx, getState());
enterRule(_localctx, 98, RULE_test);
int _la;
try {
setState(732);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(723);
or_test();
setState(729);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(724);
match(IF);
setState(725);
or_test();
setState(726);
match(ELSE);
setState(727);
test();
}
}
}
break;
case LAMBDA:
enterOuterAlt(_localctx, 2);
{
setState(731);
lambdef();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Test_nocondContext extends ParserRuleContext {
public Or_testContext or_test() {
return getRuleContext(Or_testContext.class,0);
}
public Lambdef_nocondContext lambdef_nocond() {
return getRuleContext(Lambdef_nocondContext.class,0);
}
public Test_nocondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_test_nocond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTest_nocond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTest_nocond(this);
}
}
public final Test_nocondContext test_nocond() throws RecognitionException {
Test_nocondContext _localctx = new Test_nocondContext(_ctx, getState());
enterRule(_localctx, 100, RULE_test_nocond);
try {
setState(736);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 1);
{
setState(734);
or_test();
}
break;
case LAMBDA:
enterOuterAlt(_localctx, 2);
{
setState(735);
lambdef_nocond();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LambdefContext extends ParserRuleContext {
public TerminalNode LAMBDA() { return getToken(Python3Parser.LAMBDA, 0); }
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public VarargslistContext varargslist() {
return getRuleContext(VarargslistContext.class,0);
}
public LambdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterLambdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitLambdef(this);
}
}
public final LambdefContext lambdef() throws RecognitionException {
LambdefContext _localctx = new LambdefContext(_ctx, getState());
enterRule(_localctx, 102, RULE_lambdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(738);
match(LAMBDA);
setState(740);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 146368087401168896L) != 0)) {
{
setState(739);
varargslist();
}
}
setState(742);
match(COLON);
setState(743);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Lambdef_nocondContext extends ParserRuleContext {
public TerminalNode LAMBDA() { return getToken(Python3Parser.LAMBDA, 0); }
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public Test_nocondContext test_nocond() {
return getRuleContext(Test_nocondContext.class,0);
}
public VarargslistContext varargslist() {
return getRuleContext(VarargslistContext.class,0);
}
public Lambdef_nocondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdef_nocond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterLambdef_nocond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitLambdef_nocond(this);
}
}
public final Lambdef_nocondContext lambdef_nocond() throws RecognitionException {
Lambdef_nocondContext _localctx = new Lambdef_nocondContext(_ctx, getState());
enterRule(_localctx, 104, RULE_lambdef_nocond);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(745);
match(LAMBDA);
setState(747);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 146368087401168896L) != 0)) {
{
setState(746);
varargslist();
}
}
setState(749);
match(COLON);
setState(750);
test_nocond();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Or_testContext extends ParserRuleContext {
public List and_test() {
return getRuleContexts(And_testContext.class);
}
public And_testContext and_test(int i) {
return getRuleContext(And_testContext.class,i);
}
public List OR() { return getTokens(Python3Parser.OR); }
public TerminalNode OR(int i) {
return getToken(Python3Parser.OR, i);
}
public Or_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_or_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterOr_test(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitOr_test(this);
}
}
public final Or_testContext or_test() throws RecognitionException {
Or_testContext _localctx = new Or_testContext(_ctx, getState());
enterRule(_localctx, 106, RULE_or_test);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(752);
and_test();
setState(757);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(753);
match(OR);
setState(754);
and_test();
}
}
setState(759);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class And_testContext extends ParserRuleContext {
public List not_test() {
return getRuleContexts(Not_testContext.class);
}
public Not_testContext not_test(int i) {
return getRuleContext(Not_testContext.class,i);
}
public List AND() { return getTokens(Python3Parser.AND); }
public TerminalNode AND(int i) {
return getToken(Python3Parser.AND, i);
}
public And_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAnd_test(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAnd_test(this);
}
}
public final And_testContext and_test() throws RecognitionException {
And_testContext _localctx = new And_testContext(_ctx, getState());
enterRule(_localctx, 108, RULE_and_test);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(760);
not_test();
setState(765);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(761);
match(AND);
setState(762);
not_test();
}
}
setState(767);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Not_testContext extends ParserRuleContext {
public TerminalNode NOT() { return getToken(Python3Parser.NOT, 0); }
public Not_testContext not_test() {
return getRuleContext(Not_testContext.class,0);
}
public ComparisonContext comparison() {
return getRuleContext(ComparisonContext.class,0);
}
public Not_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_not_test; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterNot_test(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitNot_test(this);
}
}
public final Not_testContext not_test() throws RecognitionException {
Not_testContext _localctx = new Not_testContext(_ctx, getState());
enterRule(_localctx, 110, RULE_not_test);
try {
setState(771);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
enterOuterAlt(_localctx, 1);
{
setState(768);
match(NOT);
setState(769);
not_test();
}
break;
case STRING:
case NUMBER:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(770);
comparison();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List comp_op() {
return getRuleContexts(Comp_opContext.class);
}
public Comp_opContext comp_op(int i) {
return getRuleContext(Comp_opContext.class,i);
}
public ComparisonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparison; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitComparison(this);
}
}
public final ComparisonContext comparison() throws RecognitionException {
ComparisonContext _localctx = new ComparisonContext(_ctx, getState());
enterRule(_localctx, 112, RULE_comparison);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(773);
expr();
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & 9151314442816848641L) != 0)) {
{
{
setState(774);
comp_op();
setState(775);
expr();
}
}
setState(781);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Comp_opContext extends ParserRuleContext {
public TerminalNode LESS_THAN() { return getToken(Python3Parser.LESS_THAN, 0); }
public TerminalNode GREATER_THAN() { return getToken(Python3Parser.GREATER_THAN, 0); }
public TerminalNode EQUALS() { return getToken(Python3Parser.EQUALS, 0); }
public TerminalNode GT_EQ() { return getToken(Python3Parser.GT_EQ, 0); }
public TerminalNode LT_EQ() { return getToken(Python3Parser.LT_EQ, 0); }
public TerminalNode NOT_EQ_1() { return getToken(Python3Parser.NOT_EQ_1, 0); }
public TerminalNode NOT_EQ_2() { return getToken(Python3Parser.NOT_EQ_2, 0); }
public TerminalNode IN() { return getToken(Python3Parser.IN, 0); }
public TerminalNode NOT() { return getToken(Python3Parser.NOT, 0); }
public TerminalNode IS() { return getToken(Python3Parser.IS, 0); }
public Comp_opContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_op; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterComp_op(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitComp_op(this);
}
}
public final Comp_opContext comp_op() throws RecognitionException {
Comp_opContext _localctx = new Comp_opContext(_ctx, getState());
enterRule(_localctx, 114, RULE_comp_op);
try {
setState(795);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(782);
match(LESS_THAN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(783);
match(GREATER_THAN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(784);
match(EQUALS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(785);
match(GT_EQ);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(786);
match(LT_EQ);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(787);
match(NOT_EQ_1);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(788);
match(NOT_EQ_2);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(789);
match(IN);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(790);
match(NOT);
setState(791);
match(IN);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(792);
match(IS);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(793);
match(IS);
setState(794);
match(NOT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Star_exprContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Star_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_star_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterStar_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitStar_expr(this);
}
}
public final Star_exprContext star_expr() throws RecognitionException {
Star_exprContext _localctx = new Star_exprContext(_ctx, getState());
enterRule(_localctx, 116, RULE_star_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(797);
match(STAR);
setState(798);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExprContext extends ParserRuleContext {
public List xor_expr() {
return getRuleContexts(Xor_exprContext.class);
}
public Xor_exprContext xor_expr(int i) {
return getRuleContext(Xor_exprContext.class,i);
}
public List OR_OP() { return getTokens(Python3Parser.OR_OP); }
public TerminalNode OR_OP(int i) {
return getToken(Python3Parser.OR_OP, i);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitExpr(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 118, RULE_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(800);
xor_expr();
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_OP) {
{
{
setState(801);
match(OR_OP);
setState(802);
xor_expr();
}
}
setState(807);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Xor_exprContext extends ParserRuleContext {
public List and_expr() {
return getRuleContexts(And_exprContext.class);
}
public And_exprContext and_expr(int i) {
return getRuleContext(And_exprContext.class,i);
}
public List XOR() { return getTokens(Python3Parser.XOR); }
public TerminalNode XOR(int i) {
return getToken(Python3Parser.XOR, i);
}
public Xor_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xor_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterXor_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitXor_expr(this);
}
}
public final Xor_exprContext xor_expr() throws RecognitionException {
Xor_exprContext _localctx = new Xor_exprContext(_ctx, getState());
enterRule(_localctx, 120, RULE_xor_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(808);
and_expr();
setState(813);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==XOR) {
{
{
setState(809);
match(XOR);
setState(810);
and_expr();
}
}
setState(815);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class And_exprContext extends ParserRuleContext {
public List shift_expr() {
return getRuleContexts(Shift_exprContext.class);
}
public Shift_exprContext shift_expr(int i) {
return getRuleContext(Shift_exprContext.class,i);
}
public List AND_OP() { return getTokens(Python3Parser.AND_OP); }
public TerminalNode AND_OP(int i) {
return getToken(Python3Parser.AND_OP, i);
}
public And_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAnd_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAnd_expr(this);
}
}
public final And_exprContext and_expr() throws RecognitionException {
And_exprContext _localctx = new And_exprContext(_ctx, getState());
enterRule(_localctx, 122, RULE_and_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(816);
shift_expr();
setState(821);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_OP) {
{
{
setState(817);
match(AND_OP);
setState(818);
shift_expr();
}
}
setState(823);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Shift_exprContext extends ParserRuleContext {
public List arith_expr() {
return getRuleContexts(Arith_exprContext.class);
}
public Arith_exprContext arith_expr(int i) {
return getRuleContext(Arith_exprContext.class,i);
}
public List LEFT_SHIFT() { return getTokens(Python3Parser.LEFT_SHIFT); }
public TerminalNode LEFT_SHIFT(int i) {
return getToken(Python3Parser.LEFT_SHIFT, i);
}
public List RIGHT_SHIFT() { return getTokens(Python3Parser.RIGHT_SHIFT); }
public TerminalNode RIGHT_SHIFT(int i) {
return getToken(Python3Parser.RIGHT_SHIFT, i);
}
public Shift_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shift_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterShift_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitShift_expr(this);
}
}
public final Shift_exprContext shift_expr() throws RecognitionException {
Shift_exprContext _localctx = new Shift_exprContext(_ctx, getState());
enterRule(_localctx, 124, RULE_shift_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(824);
arith_expr();
setState(829);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LEFT_SHIFT || _la==RIGHT_SHIFT) {
{
{
setState(825);
_la = _input.LA(1);
if ( !(_la==LEFT_SHIFT || _la==RIGHT_SHIFT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(826);
arith_expr();
}
}
setState(831);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Arith_exprContext extends ParserRuleContext {
public List term() {
return getRuleContexts(TermContext.class);
}
public TermContext term(int i) {
return getRuleContext(TermContext.class,i);
}
public List ADD() { return getTokens(Python3Parser.ADD); }
public TerminalNode ADD(int i) {
return getToken(Python3Parser.ADD, i);
}
public List MINUS() { return getTokens(Python3Parser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(Python3Parser.MINUS, i);
}
public Arith_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arith_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterArith_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitArith_expr(this);
}
}
public final Arith_exprContext arith_expr() throws RecognitionException {
Arith_exprContext _localctx = new Arith_exprContext(_ctx, getState());
enterRule(_localctx, 126, RULE_arith_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(832);
term();
setState(837);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ADD || _la==MINUS) {
{
{
setState(833);
_la = _input.LA(1);
if ( !(_la==ADD || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(834);
term();
}
}
setState(839);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TermContext extends ParserRuleContext {
public List factor() {
return getRuleContexts(FactorContext.class);
}
public FactorContext factor(int i) {
return getRuleContext(FactorContext.class,i);
}
public List STAR() { return getTokens(Python3Parser.STAR); }
public TerminalNode STAR(int i) {
return getToken(Python3Parser.STAR, i);
}
public List AT() { return getTokens(Python3Parser.AT); }
public TerminalNode AT(int i) {
return getToken(Python3Parser.AT, i);
}
public List DIV() { return getTokens(Python3Parser.DIV); }
public TerminalNode DIV(int i) {
return getToken(Python3Parser.DIV, i);
}
public List MOD() { return getTokens(Python3Parser.MOD); }
public TerminalNode MOD(int i) {
return getToken(Python3Parser.MOD, i);
}
public List IDIV() { return getTokens(Python3Parser.IDIV); }
public TerminalNode IDIV(int i) {
return getToken(Python3Parser.IDIV, i);
}
public TermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTerm(this);
}
}
public final TermContext term() throws RecognitionException {
TermContext _localctx = new TermContext(_ctx, getState());
enterRule(_localctx, 128, RULE_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(840);
factor();
setState(845);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 1074659329L) != 0)) {
{
{
setState(841);
_la = _input.LA(1);
if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 1074659329L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(842);
factor();
}
}
setState(847);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FactorContext extends ParserRuleContext {
public FactorContext factor() {
return getRuleContext(FactorContext.class,0);
}
public TerminalNode ADD() { return getToken(Python3Parser.ADD, 0); }
public TerminalNode MINUS() { return getToken(Python3Parser.MINUS, 0); }
public TerminalNode NOT_OP() { return getToken(Python3Parser.NOT_OP, 0); }
public PowerContext power() {
return getRuleContext(PowerContext.class,0);
}
public FactorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_factor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterFactor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitFactor(this);
}
}
public final FactorContext factor() throws RecognitionException {
FactorContext _localctx = new FactorContext(_ctx, getState());
enterRule(_localctx, 130, RULE_factor);
int _la;
try {
setState(851);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ADD:
case MINUS:
case NOT_OP:
enterOuterAlt(_localctx, 1);
{
setState(848);
_la = _input.LA(1);
if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 35L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(849);
factor();
}
break;
case STRING:
case NUMBER:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(850);
power();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PowerContext extends ParserRuleContext {
public Atom_exprContext atom_expr() {
return getRuleContext(Atom_exprContext.class,0);
}
public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); }
public FactorContext factor() {
return getRuleContext(FactorContext.class,0);
}
public PowerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_power; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterPower(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitPower(this);
}
}
public final PowerContext power() throws RecognitionException {
PowerContext _localctx = new PowerContext(_ctx, getState());
enterRule(_localctx, 132, RULE_power);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(853);
atom_expr();
setState(856);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(854);
match(POWER);
setState(855);
factor();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Atom_exprContext extends ParserRuleContext {
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public TerminalNode AWAIT() { return getToken(Python3Parser.AWAIT, 0); }
public List trailer() {
return getRuleContexts(TrailerContext.class);
}
public TrailerContext trailer(int i) {
return getRuleContext(TrailerContext.class,i);
}
public Atom_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAtom_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAtom_expr(this);
}
}
public final Atom_exprContext atom_expr() throws RecognitionException {
Atom_exprContext _localctx = new Atom_exprContext(_ctx, getState());
enterRule(_localctx, 134, RULE_atom_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(859);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AWAIT) {
{
setState(858);
match(AWAIT);
}
}
setState(861);
atom();
setState(865);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 581527301884215296L) != 0)) {
{
{
setState(862);
trailer();
}
}
setState(867);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AtomContext extends ParserRuleContext {
public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); }
public TerminalNode OPEN_BRACK() { return getToken(Python3Parser.OPEN_BRACK, 0); }
public TerminalNode CLOSE_BRACK() { return getToken(Python3Parser.CLOSE_BRACK, 0); }
public TerminalNode OPEN_BRACE() { return getToken(Python3Parser.OPEN_BRACE, 0); }
public TerminalNode CLOSE_BRACE() { return getToken(Python3Parser.CLOSE_BRACE, 0); }
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public TerminalNode NUMBER() { return getToken(Python3Parser.NUMBER, 0); }
public TerminalNode ELLIPSIS() { return getToken(Python3Parser.ELLIPSIS, 0); }
public TerminalNode NONE() { return getToken(Python3Parser.NONE, 0); }
public TerminalNode TRUE() { return getToken(Python3Parser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(Python3Parser.FALSE, 0); }
public Yield_exprContext yield_expr() {
return getRuleContext(Yield_exprContext.class,0);
}
public Testlist_compContext testlist_comp() {
return getRuleContext(Testlist_compContext.class,0);
}
public DictorsetmakerContext dictorsetmaker() {
return getRuleContext(DictorsetmakerContext.class,0);
}
public List STRING() { return getTokens(Python3Parser.STRING); }
public TerminalNode STRING(int i) {
return getToken(Python3Parser.STRING, i);
}
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitAtom(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 136, RULE_atom);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(895);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAREN:
{
setState(868);
match(OPEN_PAREN);
setState(871);
_errHandler.sync(this);
switch (_input.LA(1)) {
case YIELD:
{
setState(869);
yield_expr();
}
break;
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case STAR:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(870);
testlist_comp();
}
break;
case CLOSE_PAREN:
break;
default:
break;
}
setState(873);
match(CLOSE_PAREN);
}
break;
case OPEN_BRACK:
{
setState(874);
match(OPEN_BRACK);
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 584343427995402246L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(875);
testlist_comp();
}
}
setState(878);
match(CLOSE_BRACK);
}
break;
case OPEN_BRACE:
{
setState(879);
match(OPEN_BRACE);
setState(881);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 728458616071258118L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(880);
dictorsetmaker();
}
}
setState(883);
match(CLOSE_BRACE);
}
break;
case NAME:
{
setState(884);
match(NAME);
}
break;
case NUMBER:
{
setState(885);
match(NUMBER);
}
break;
case STRING:
{
setState(887);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(886);
match(STRING);
}
}
setState(889);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==STRING );
}
break;
case ELLIPSIS:
{
setState(891);
match(ELLIPSIS);
}
break;
case NONE:
{
setState(892);
match(NONE);
}
break;
case TRUE:
{
setState(893);
match(TRUE);
}
break;
case FALSE:
{
setState(894);
match(FALSE);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Testlist_compContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List star_expr() {
return getRuleContexts(Star_exprContext.class);
}
public Star_exprContext star_expr(int i) {
return getRuleContext(Star_exprContext.class,i);
}
public Comp_forContext comp_for() {
return getRuleContext(Comp_forContext.class,0);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public Testlist_compContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist_comp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTestlist_comp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTestlist_comp(this);
}
}
public final Testlist_compContext testlist_comp() throws RecognitionException {
Testlist_compContext _localctx = new Testlist_compContext(_ctx, getState());
enterRule(_localctx, 138, RULE_testlist_comp);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(899);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(897);
test();
}
break;
case STAR:
{
setState(898);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(915);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOR:
case ASYNC:
{
setState(901);
comp_for();
}
break;
case CLOSE_PAREN:
case COMMA:
case CLOSE_BRACK:
{
setState(909);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(902);
match(COMMA);
setState(905);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(903);
test();
}
break;
case STAR:
{
setState(904);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
setState(911);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
}
setState(913);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(912);
match(COMMA);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TrailerContext extends ParserRuleContext {
public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); }
public ArglistContext arglist() {
return getRuleContext(ArglistContext.class,0);
}
public TerminalNode OPEN_BRACK() { return getToken(Python3Parser.OPEN_BRACK, 0); }
public SubscriptlistContext subscriptlist() {
return getRuleContext(SubscriptlistContext.class,0);
}
public TerminalNode CLOSE_BRACK() { return getToken(Python3Parser.CLOSE_BRACK, 0); }
public TerminalNode DOT() { return getToken(Python3Parser.DOT, 0); }
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public TrailerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTrailer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTrailer(this);
}
}
public final TrailerContext trailer() throws RecognitionException {
TrailerContext _localctx = new TrailerContext(_ctx, getState());
enterRule(_localctx, 140, RULE_trailer);
int _la;
try {
setState(928);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAREN:
enterOuterAlt(_localctx, 1);
{
setState(917);
match(OPEN_PAREN);
setState(919);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 728458616071258118L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(918);
arglist();
}
}
setState(921);
match(CLOSE_PAREN);
}
break;
case OPEN_BRACK:
enterOuterAlt(_localctx, 2);
{
setState(922);
match(OPEN_BRACK);
setState(923);
subscriptlist();
setState(924);
match(CLOSE_BRACK);
}
break;
case DOT:
enterOuterAlt(_localctx, 3);
{
setState(926);
match(DOT);
setState(927);
match(NAME);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubscriptlistContext extends ParserRuleContext {
public List subscript() {
return getRuleContexts(SubscriptContext.class);
}
public SubscriptContext subscript(int i) {
return getRuleContext(SubscriptContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public SubscriptlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subscriptlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSubscriptlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSubscriptlist(this);
}
}
public final SubscriptlistContext subscriptlist() throws RecognitionException {
SubscriptlistContext _localctx = new SubscriptlistContext(_ctx, getState());
enterRule(_localctx, 142, RULE_subscriptlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(930);
subscript();
setState(935);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(931);
match(COMMA);
setState(932);
subscript();
}
}
}
setState(937);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
}
setState(939);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(938);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SubscriptContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public SliceopContext sliceop() {
return getRuleContext(SliceopContext.class,0);
}
public SubscriptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subscript; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSubscript(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSubscript(this);
}
}
public final SubscriptContext subscript() throws RecognitionException {
SubscriptContext _localctx = new SubscriptContext(_ctx, getState());
enterRule(_localctx, 144, RULE_subscript);
int _la;
try {
setState(952);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(941);
test();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(943);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181716998L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(942);
test();
}
}
setState(945);
match(COLON);
setState(947);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181716998L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(946);
test();
}
}
setState(950);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(949);
sliceop();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SliceopContext extends ParserRuleContext {
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public SliceopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sliceop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterSliceop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitSliceop(this);
}
}
public final SliceopContext sliceop() throws RecognitionException {
SliceopContext _localctx = new SliceopContext(_ctx, getState());
enterRule(_localctx, 146, RULE_sliceop);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(954);
match(COLON);
setState(956);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181716998L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(955);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExprlistContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List star_expr() {
return getRuleContexts(Star_exprContext.class);
}
public Star_exprContext star_expr(int i) {
return getRuleContext(Star_exprContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public ExprlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterExprlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitExprlist(this);
}
}
public final ExprlistContext exprlist() throws RecognitionException {
ExprlistContext _localctx = new ExprlistContext(_ctx, getState());
enterRule(_localctx, 148, RULE_exprlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(960);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(958);
expr();
}
break;
case STAR:
{
setState(959);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(969);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,139,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(962);
match(COMMA);
setState(965);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(963);
expr();
}
break;
case STAR:
{
setState(964);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
setState(971);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,139,_ctx);
}
setState(973);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(972);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TestlistContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public TestlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterTestlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitTestlist(this);
}
}
public final TestlistContext testlist() throws RecognitionException {
TestlistContext _localctx = new TestlistContext(_ctx, getState());
enterRule(_localctx, 150, RULE_testlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(975);
test();
setState(980);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,141,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(976);
match(COMMA);
setState(977);
test();
}
}
}
setState(982);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,141,_ctx);
}
setState(984);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(983);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DictorsetmakerContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List COLON() { return getTokens(Python3Parser.COLON); }
public TerminalNode COLON(int i) {
return getToken(Python3Parser.COLON, i);
}
public List POWER() { return getTokens(Python3Parser.POWER); }
public TerminalNode POWER(int i) {
return getToken(Python3Parser.POWER, i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Comp_forContext comp_for() {
return getRuleContext(Comp_forContext.class,0);
}
public List star_expr() {
return getRuleContexts(Star_exprContext.class);
}
public Star_exprContext star_expr(int i) {
return getRuleContext(Star_exprContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public DictorsetmakerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dictorsetmaker; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterDictorsetmaker(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitDictorsetmaker(this);
}
}
public final DictorsetmakerContext dictorsetmaker() throws RecognitionException {
DictorsetmakerContext _localctx = new DictorsetmakerContext(_ctx, getState());
enterRule(_localctx, 152, RULE_dictorsetmaker);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1034);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
{
{
setState(992);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(986);
test();
setState(987);
match(COLON);
setState(988);
test();
}
break;
case POWER:
{
setState(990);
match(POWER);
setState(991);
expr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1012);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOR:
case ASYNC:
{
setState(994);
comp_for();
}
break;
case COMMA:
case CLOSE_BRACE:
{
setState(1006);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(995);
match(COMMA);
setState(1002);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(996);
test();
setState(997);
match(COLON);
setState(998);
test();
}
break;
case POWER:
{
setState(1000);
match(POWER);
setState(1001);
expr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
setState(1008);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
}
setState(1010);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1009);
match(COMMA);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
case 2:
{
{
setState(1016);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(1014);
test();
}
break;
case STAR:
{
setState(1015);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1032);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOR:
case ASYNC:
{
setState(1018);
comp_for();
}
break;
case COMMA:
case CLOSE_BRACE:
{
setState(1026);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1019);
match(COMMA);
setState(1022);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
{
setState(1020);
test();
}
break;
case STAR:
{
setState(1021);
star_expr();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
setState(1028);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
}
setState(1030);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1029);
match(COMMA);
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClassdefContext extends ParserRuleContext {
public TerminalNode CLASS() { return getToken(Python3Parser.CLASS, 0); }
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); }
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); }
public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); }
public ArglistContext arglist() {
return getRuleContext(ArglistContext.class,0);
}
public ClassdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classdef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterClassdef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitClassdef(this);
}
}
public final ClassdefContext classdef() throws RecognitionException {
ClassdefContext _localctx = new ClassdefContext(_ctx, getState());
enterRule(_localctx, 154, RULE_classdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1036);
match(CLASS);
setState(1037);
match(NAME);
setState(1043);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAREN) {
{
setState(1038);
match(OPEN_PAREN);
setState(1040);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 728458616071258118L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(1039);
arglist();
}
}
setState(1042);
match(CLOSE_PAREN);
}
}
setState(1045);
match(COLON);
setState(1046);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArglistContext extends ParserRuleContext {
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public List COMMA() { return getTokens(Python3Parser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(Python3Parser.COMMA, i);
}
public ArglistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arglist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterArglist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitArglist(this);
}
}
public final ArglistContext arglist() throws RecognitionException {
ArglistContext _localctx = new ArglistContext(_ctx, getState());
enterRule(_localctx, 156, RULE_arglist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1048);
argument();
setState(1053);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1049);
match(COMMA);
setState(1050);
argument();
}
}
}
setState(1055);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
}
setState(1057);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1056);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArgumentContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public TerminalNode ASSIGN() { return getToken(Python3Parser.ASSIGN, 0); }
public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); }
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public Comp_forContext comp_for() {
return getRuleContext(Comp_forContext.class,0);
}
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitArgument(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 158, RULE_argument);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1071);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1059);
test();
setState(1061);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FOR || _la==ASYNC) {
{
setState(1060);
comp_for();
}
}
}
break;
case 2:
{
setState(1063);
test();
setState(1064);
match(ASSIGN);
setState(1065);
test();
}
break;
case 3:
{
setState(1067);
match(POWER);
setState(1068);
test();
}
break;
case 4:
{
setState(1069);
match(STAR);
setState(1070);
test();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Comp_iterContext extends ParserRuleContext {
public Comp_forContext comp_for() {
return getRuleContext(Comp_forContext.class,0);
}
public Comp_ifContext comp_if() {
return getRuleContext(Comp_ifContext.class,0);
}
public Comp_iterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_iter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterComp_iter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitComp_iter(this);
}
}
public final Comp_iterContext comp_iter() throws RecognitionException {
Comp_iterContext _localctx = new Comp_iterContext(_ctx, getState());
enterRule(_localctx, 160, RULE_comp_iter);
try {
setState(1075);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FOR:
case ASYNC:
enterOuterAlt(_localctx, 1);
{
setState(1073);
comp_for();
}
break;
case IF:
enterOuterAlt(_localctx, 2);
{
setState(1074);
comp_if();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Comp_forContext extends ParserRuleContext {
public TerminalNode FOR() { return getToken(Python3Parser.FOR, 0); }
public ExprlistContext exprlist() {
return getRuleContext(ExprlistContext.class,0);
}
public TerminalNode IN() { return getToken(Python3Parser.IN, 0); }
public Or_testContext or_test() {
return getRuleContext(Or_testContext.class,0);
}
public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); }
public Comp_iterContext comp_iter() {
return getRuleContext(Comp_iterContext.class,0);
}
public Comp_forContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_for; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterComp_for(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitComp_for(this);
}
}
public final Comp_forContext comp_for() throws RecognitionException {
Comp_forContext _localctx = new Comp_forContext(_ctx, getState());
enterRule(_localctx, 162, RULE_comp_for);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1078);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYNC) {
{
setState(1077);
match(ASYNC);
}
}
setState(1080);
match(FOR);
setState(1081);
exprlist();
setState(1082);
match(IN);
setState(1083);
or_test();
setState(1085);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 137439092736L) != 0)) {
{
setState(1084);
comp_iter();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Comp_ifContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(Python3Parser.IF, 0); }
public Test_nocondContext test_nocond() {
return getRuleContext(Test_nocondContext.class,0);
}
public Comp_iterContext comp_iter() {
return getRuleContext(Comp_iterContext.class,0);
}
public Comp_ifContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_if; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterComp_if(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitComp_if(this);
}
}
public final Comp_ifContext comp_if() throws RecognitionException {
Comp_ifContext _localctx = new Comp_ifContext(_ctx, getState());
enterRule(_localctx, 164, RULE_comp_if);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1087);
match(IF);
setState(1088);
test_nocond();
setState(1090);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 137439092736L) != 0)) {
{
setState(1089);
comp_iter();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Encoding_declContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public Encoding_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_encoding_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterEncoding_decl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitEncoding_decl(this);
}
}
public final Encoding_declContext encoding_decl() throws RecognitionException {
Encoding_declContext _localctx = new Encoding_declContext(_ctx, getState());
enterRule(_localctx, 166, RULE_encoding_decl);
try {
enterOuterAlt(_localctx, 1);
{
setState(1092);
match(NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Yield_exprContext extends ParserRuleContext {
public TerminalNode YIELD() { return getToken(Python3Parser.YIELD, 0); }
public Yield_argContext yield_arg() {
return getRuleContext(Yield_argContext.class,0);
}
public Yield_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_yield_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterYield_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitYield_expr(this);
}
}
public final Yield_exprContext yield_expr() throws RecognitionException {
Yield_exprContext _localctx = new Yield_exprContext(_ctx, getState());
enterRule(_localctx, 168, RULE_yield_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1094);
match(YIELD);
setState(1096);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 582091628181717126L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 99L) != 0)) {
{
setState(1095);
yield_arg();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Yield_argContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(Python3Parser.FROM, 0); }
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public Yield_argContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_yield_arg; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).enterYield_arg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Python3Listener ) ((Python3Listener)listener).exitYield_arg(this);
}
}
public final Yield_argContext yield_arg() throws RecognitionException {
Yield_argContext _localctx = new Yield_argContext(_ctx, getState());
enterRule(_localctx, 170, RULE_yield_arg);
try {
setState(1101);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
enterOuterAlt(_localctx, 1);
{
setState(1098);
match(FROM);
setState(1099);
test();
}
break;
case STRING:
case NUMBER:
case LAMBDA:
case NOT:
case NONE:
case TRUE:
case FALSE:
case AWAIT:
case NAME:
case ELLIPSIS:
case OPEN_PAREN:
case OPEN_BRACK:
case ADD:
case MINUS:
case NOT_OP:
case OPEN_BRACE:
enterOuterAlt(_localctx, 2);
{
setState(1100);
testlist();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\u0004\u0001c\u0450\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
"-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+
"2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+
"7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+
"<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+
"A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+
"F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+
"K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+
"P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+
"U\u0007U\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0003"+
"\u0000\u00b2\b\u0000\u0001\u0001\u0001\u0001\u0005\u0001\u00b6\b\u0001"+
"\n\u0001\f\u0001\u00b9\t\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001"+
"\u0002\u0005\u0002\u00bf\b\u0002\n\u0002\f\u0002\u00c2\t\u0002\u0001\u0002"+
"\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003"+
"\u00ca\b\u0003\u0001\u0003\u0003\u0003\u00cd\b\u0003\u0001\u0003\u0001"+
"\u0003\u0001\u0004\u0004\u0004\u00d2\b\u0004\u000b\u0004\f\u0004\u00d3"+
"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u00da\b\u0005"+
"\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007"+
"\u0001\u0007\u0001\u0007\u0003\u0007\u00e4\b\u0007\u0001\u0007\u0001\u0007"+
"\u0001\u0007\u0001\b\u0001\b\u0003\b\u00eb\b\b\u0001\b\u0001\b\u0001\t"+
"\u0001\t\u0001\t\u0003\t\u00f2\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003"+
"\t\u00f8\b\t\u0005\t\u00fa\b\t\n\t\f\t\u00fd\t\t\u0001\t\u0001\t\u0001"+
"\t\u0003\t\u0102\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u0108\b\t"+
"\u0005\t\u010a\b\t\n\t\f\t\u010d\t\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003"+
"\t\u0113\b\t\u0003\t\u0115\b\t\u0003\t\u0117\b\t\u0001\t\u0001\t\u0001"+
"\t\u0003\t\u011c\b\t\u0003\t\u011e\b\t\u0003\t\u0120\b\t\u0001\t\u0001"+
"\t\u0003\t\u0124\b\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u012a\b\t"+
"\u0005\t\u012c\b\t\n\t\f\t\u012f\t\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003"+
"\t\u0135\b\t\u0003\t\u0137\b\t\u0003\t\u0139\b\t\u0001\t\u0001\t\u0001"+
"\t\u0003\t\u013e\b\t\u0003\t\u0140\b\t\u0001\n\u0001\n\u0001\n\u0003\n"+
"\u0145\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u014a\b\u000b"+
"\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0150\b\u000b"+
"\u0005\u000b\u0152\b\u000b\n\u000b\f\u000b\u0155\t\u000b\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0003\u000b\u015a\b\u000b\u0001\u000b\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0003\u000b\u0160\b\u000b\u0005\u000b\u0162\b\u000b"+
"\n\u000b\f\u000b\u0165\t\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+
"\u000b\u0003\u000b\u016b\b\u000b\u0003\u000b\u016d\b\u000b\u0003\u000b"+
"\u016f\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0174\b"+
"\u000b\u0003\u000b\u0176\b\u000b\u0003\u000b\u0178\b\u000b\u0001\u000b"+
"\u0001\u000b\u0003\u000b\u017c\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
"\u0001\u000b\u0003\u000b\u0182\b\u000b\u0005\u000b\u0184\b\u000b\n\u000b"+
"\f\u000b\u0187\t\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+
"\u0003\u000b\u018d\b\u000b\u0003\u000b\u018f\b\u000b\u0003\u000b\u0191"+
"\b\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0196\b\u000b"+
"\u0003\u000b\u0198\b\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0003\r\u019e"+
"\b\r\u0001\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u01a3\b\u000e\n\u000e"+
"\f\u000e\u01a6\t\u000e\u0001\u000e\u0003\u000e\u01a9\b\u000e\u0001\u000e"+
"\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u01b5\b\u000f\u0001\u0010"+
"\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u01bc\b\u0010"+
"\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u01c1\b\u0010\u0005\u0010"+
"\u01c3\b\u0010\n\u0010\f\u0010\u01c6\t\u0010\u0003\u0010\u01c8\b\u0010"+
"\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0003\u0011\u01ce\b\u0011"+
"\u0001\u0012\u0001\u0012\u0003\u0012\u01d2\b\u0012\u0001\u0012\u0001\u0012"+
"\u0001\u0012\u0003\u0012\u01d7\b\u0012\u0005\u0012\u01d9\b\u0012\n\u0012"+
"\f\u0012\u01dc\t\u0012\u0001\u0012\u0003\u0012\u01df\b\u0012\u0001\u0013"+
"\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015"+
"\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
"\u01ed\b\u0016\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019"+
"\u0001\u0019\u0003\u0019\u01f5\b\u0019\u0001\u001a\u0001\u001a\u0001\u001b"+
"\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u01fd\b\u001b\u0003\u001b"+
"\u01ff\b\u001b\u0001\u001c\u0001\u001c\u0003\u001c\u0203\b\u001c\u0001"+
"\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0005\u001e\u020a"+
"\b\u001e\n\u001e\f\u001e\u020d\t\u001e\u0001\u001e\u0001\u001e\u0004\u001e"+
"\u0211\b\u001e\u000b\u001e\f\u001e\u0212\u0003\u001e\u0215\b\u001e\u0001"+
"\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+
"\u001e\u0003\u001e\u021e\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0003"+
"\u001f\u0223\b\u001f\u0001 \u0001 \u0001 \u0003 \u0228\b \u0001!\u0001"+
"!\u0001!\u0005!\u022d\b!\n!\f!\u0230\t!\u0001!\u0003!\u0233\b!\u0001\""+
"\u0001\"\u0001\"\u0005\"\u0238\b\"\n\"\f\"\u023b\t\"\u0001#\u0001#\u0001"+
"#\u0005#\u0240\b#\n#\f#\u0243\t#\u0001$\u0001$\u0001$\u0001$\u0005$\u0249"+
"\b$\n$\f$\u024c\t$\u0001%\u0001%\u0001%\u0001%\u0005%\u0252\b%\n%\f%\u0255"+
"\t%\u0001&\u0001&\u0001&\u0001&\u0003&\u025b\b&\u0001\'\u0001\'\u0001"+
"\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0003\'\u0266\b\'\u0001"+
"(\u0001(\u0001(\u0001(\u0003(\u026c\b(\u0001)\u0001)\u0001)\u0001)\u0001"+
")\u0001)\u0001)\u0001)\u0001)\u0005)\u0277\b)\n)\f)\u027a\t)\u0001)\u0001"+
")\u0001)\u0003)\u027f\b)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+
"*\u0003*\u0288\b*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+
"+\u0001+\u0003+\u0293\b+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+
",\u0004,\u029c\b,\u000b,\f,\u029d\u0001,\u0001,\u0001,\u0003,\u02a3\b"+
",\u0001,\u0001,\u0001,\u0003,\u02a8\b,\u0001,\u0001,\u0001,\u0003,\u02ad"+
"\b,\u0001-\u0001-\u0001-\u0001-\u0005-\u02b3\b-\n-\f-\u02b6\t-\u0001-"+
"\u0001-\u0001-\u0001.\u0001.\u0001.\u0003.\u02be\b.\u0001/\u0001/\u0001"+
"/\u0001/\u0003/\u02c4\b/\u0003/\u02c6\b/\u00010\u00010\u00010\u00010\u0004"+
"0\u02cc\b0\u000b0\f0\u02cd\u00010\u00010\u00030\u02d2\b0\u00011\u0001"+
"1\u00011\u00011\u00011\u00011\u00031\u02da\b1\u00011\u00031\u02dd\b1\u0001"+
"2\u00012\u00032\u02e1\b2\u00013\u00013\u00033\u02e5\b3\u00013\u00013\u0001"+
"3\u00014\u00014\u00034\u02ec\b4\u00014\u00014\u00014\u00015\u00015\u0001"+
"5\u00055\u02f4\b5\n5\f5\u02f7\t5\u00016\u00016\u00016\u00056\u02fc\b6"+
"\n6\f6\u02ff\t6\u00017\u00017\u00017\u00037\u0304\b7\u00018\u00018\u0001"+
"8\u00018\u00058\u030a\b8\n8\f8\u030d\t8\u00019\u00019\u00019\u00019\u0001"+
"9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00039\u031c"+
"\b9\u0001:\u0001:\u0001:\u0001;\u0001;\u0001;\u0005;\u0324\b;\n;\f;\u0327"+
"\t;\u0001<\u0001<\u0001<\u0005<\u032c\b<\n<\f<\u032f\t<\u0001=\u0001="+
"\u0001=\u0005=\u0334\b=\n=\f=\u0337\t=\u0001>\u0001>\u0001>\u0005>\u033c"+
"\b>\n>\f>\u033f\t>\u0001?\u0001?\u0001?\u0005?\u0344\b?\n?\f?\u0347\t"+
"?\u0001@\u0001@\u0001@\u0005@\u034c\b@\n@\f@\u034f\t@\u0001A\u0001A\u0001"+
"A\u0003A\u0354\bA\u0001B\u0001B\u0001B\u0003B\u0359\bB\u0001C\u0003C\u035c"+
"\bC\u0001C\u0001C\u0005C\u0360\bC\nC\fC\u0363\tC\u0001D\u0001D\u0001D"+
"\u0003D\u0368\bD\u0001D\u0001D\u0001D\u0003D\u036d\bD\u0001D\u0001D\u0001"+
"D\u0003D\u0372\bD\u0001D\u0001D\u0001D\u0001D\u0004D\u0378\bD\u000bD\f"+
"D\u0379\u0001D\u0001D\u0001D\u0001D\u0003D\u0380\bD\u0001E\u0001E\u0003"+
"E\u0384\bE\u0001E\u0001E\u0001E\u0001E\u0003E\u038a\bE\u0005E\u038c\b"+
"E\nE\fE\u038f\tE\u0001E\u0003E\u0392\bE\u0003E\u0394\bE\u0001F\u0001F"+
"\u0003F\u0398\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003"+
"F\u03a1\bF\u0001G\u0001G\u0001G\u0005G\u03a6\bG\nG\fG\u03a9\tG\u0001G"+
"\u0003G\u03ac\bG\u0001H\u0001H\u0003H\u03b0\bH\u0001H\u0001H\u0003H\u03b4"+
"\bH\u0001H\u0003H\u03b7\bH\u0003H\u03b9\bH\u0001I\u0001I\u0003I\u03bd"+
"\bI\u0001J\u0001J\u0003J\u03c1\bJ\u0001J\u0001J\u0001J\u0003J\u03c6\b"+
"J\u0005J\u03c8\bJ\nJ\fJ\u03cb\tJ\u0001J\u0003J\u03ce\bJ\u0001K\u0001K"+
"\u0001K\u0005K\u03d3\bK\nK\fK\u03d6\tK\u0001K\u0003K\u03d9\bK\u0001L\u0001"+
"L\u0001L\u0001L\u0001L\u0001L\u0003L\u03e1\bL\u0001L\u0001L\u0001L\u0001"+
"L\u0001L\u0001L\u0001L\u0001L\u0003L\u03eb\bL\u0005L\u03ed\bL\nL\fL\u03f0"+
"\tL\u0001L\u0003L\u03f3\bL\u0003L\u03f5\bL\u0001L\u0001L\u0003L\u03f9"+
"\bL\u0001L\u0001L\u0001L\u0001L\u0003L\u03ff\bL\u0005L\u0401\bL\nL\fL"+
"\u0404\tL\u0001L\u0003L\u0407\bL\u0003L\u0409\bL\u0003L\u040b\bL\u0001"+
"M\u0001M\u0001M\u0001M\u0003M\u0411\bM\u0001M\u0003M\u0414\bM\u0001M\u0001"+
"M\u0001M\u0001N\u0001N\u0001N\u0005N\u041c\bN\nN\fN\u041f\tN\u0001N\u0003"+
"N\u0422\bN\u0001O\u0001O\u0003O\u0426\bO\u0001O\u0001O\u0001O\u0001O\u0001"+
"O\u0001O\u0001O\u0001O\u0003O\u0430\bO\u0001P\u0001P\u0003P\u0434\bP\u0001"+
"Q\u0003Q\u0437\bQ\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0003Q\u043e\bQ\u0001"+
"R\u0001R\u0001R\u0003R\u0443\bR\u0001S\u0001S\u0001T\u0001T\u0003T\u0449"+
"\bT\u0001U\u0001U\u0001U\u0003U\u044e\bU\u0001U\u0000\u0000V\u0000\u0002"+
"\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e"+
" \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+
"\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e"+
"\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u0000\u0006\u0001\u0000S_\u0001\u0000"+
"12\u0001\u0000@A\u0001\u0000BC\u0003\u000033DFQQ\u0002\u0000BCGG\u04cd"+
"\u0000\u00b1\u0001\u0000\u0000\u0000\u0002\u00b7\u0001\u0000\u0000\u0000"+
"\u0004\u00bc\u0001\u0000\u0000\u0000\u0006\u00c5\u0001\u0000\u0000\u0000"+
"\b\u00d1\u0001\u0000\u0000\u0000\n\u00d5\u0001\u0000\u0000\u0000\f\u00db"+
"\u0001\u0000\u0000\u0000\u000e\u00de\u0001\u0000\u0000\u0000\u0010\u00e8"+
"\u0001\u0000\u0000\u0000\u0012\u013f\u0001\u0000\u0000\u0000\u0014\u0141"+
"\u0001\u0000\u0000\u0000\u0016\u0197\u0001\u0000\u0000\u0000\u0018\u0199"+
"\u0001\u0000\u0000\u0000\u001a\u019d\u0001\u0000\u0000\u0000\u001c\u019f"+
"\u0001\u0000\u0000\u0000\u001e\u01b4\u0001\u0000\u0000\u0000 \u01b6\u0001"+
"\u0000\u0000\u0000\"\u01c9\u0001\u0000\u0000\u0000$\u01d1\u0001\u0000"+
"\u0000\u0000&\u01e0\u0001\u0000\u0000\u0000(\u01e2\u0001\u0000\u0000\u0000"+
"*\u01e5\u0001\u0000\u0000\u0000,\u01ec\u0001\u0000\u0000\u0000.\u01ee"+
"\u0001\u0000\u0000\u00000\u01f0\u0001\u0000\u0000\u00002\u01f2\u0001\u0000"+
"\u0000\u00004\u01f6\u0001\u0000\u0000\u00006\u01f8\u0001\u0000\u0000\u0000"+
"8\u0202\u0001\u0000\u0000\u0000:\u0204\u0001\u0000\u0000\u0000<\u0207"+
"\u0001\u0000\u0000\u0000>\u021f\u0001\u0000\u0000\u0000@\u0224\u0001\u0000"+
"\u0000\u0000B\u0229\u0001\u0000\u0000\u0000D\u0234\u0001\u0000\u0000\u0000"+
"F\u023c\u0001\u0000\u0000\u0000H\u0244\u0001\u0000\u0000\u0000J\u024d"+
"\u0001\u0000\u0000\u0000L\u0256\u0001\u0000\u0000\u0000N\u0265\u0001\u0000"+
"\u0000\u0000P\u0267\u0001\u0000\u0000\u0000R\u026d\u0001\u0000\u0000\u0000"+
"T\u0280\u0001\u0000\u0000\u0000V\u0289\u0001\u0000\u0000\u0000X\u0294"+
"\u0001\u0000\u0000\u0000Z\u02ae\u0001\u0000\u0000\u0000\\\u02ba\u0001"+
"\u0000\u0000\u0000^\u02bf\u0001\u0000\u0000\u0000`\u02d1\u0001\u0000\u0000"+
"\u0000b\u02dc\u0001\u0000\u0000\u0000d\u02e0\u0001\u0000\u0000\u0000f"+
"\u02e2\u0001\u0000\u0000\u0000h\u02e9\u0001\u0000\u0000\u0000j\u02f0\u0001"+
"\u0000\u0000\u0000l\u02f8\u0001\u0000\u0000\u0000n\u0303\u0001\u0000\u0000"+
"\u0000p\u0305\u0001\u0000\u0000\u0000r\u031b\u0001\u0000\u0000\u0000t"+
"\u031d\u0001\u0000\u0000\u0000v\u0320\u0001\u0000\u0000\u0000x\u0328\u0001"+
"\u0000\u0000\u0000z\u0330\u0001\u0000\u0000\u0000|\u0338\u0001\u0000\u0000"+
"\u0000~\u0340\u0001\u0000\u0000\u0000\u0080\u0348\u0001\u0000\u0000\u0000"+
"\u0082\u0353\u0001\u0000\u0000\u0000\u0084\u0355\u0001\u0000\u0000\u0000"+
"\u0086\u035b\u0001\u0000\u0000\u0000\u0088\u037f\u0001\u0000\u0000\u0000"+
"\u008a\u0383\u0001\u0000\u0000\u0000\u008c\u03a0\u0001\u0000\u0000\u0000"+
"\u008e\u03a2\u0001\u0000\u0000\u0000\u0090\u03b8\u0001\u0000\u0000\u0000"+
"\u0092\u03ba\u0001\u0000\u0000\u0000\u0094\u03c0\u0001\u0000\u0000\u0000"+
"\u0096\u03cf\u0001\u0000\u0000\u0000\u0098\u040a\u0001\u0000\u0000\u0000"+
"\u009a\u040c\u0001\u0000\u0000\u0000\u009c\u0418\u0001\u0000\u0000\u0000"+
"\u009e\u042f\u0001\u0000\u0000\u0000\u00a0\u0433\u0001\u0000\u0000\u0000"+
"\u00a2\u0436\u0001\u0000\u0000\u0000\u00a4\u043f\u0001\u0000\u0000\u0000"+
"\u00a6\u0444\u0001\u0000\u0000\u0000\u00a8\u0446\u0001\u0000\u0000\u0000"+
"\u00aa\u044d\u0001\u0000\u0000\u0000\u00ac\u00b2\u0005\'\u0000\u0000\u00ad"+
"\u00b2\u0003\u001c\u000e\u0000\u00ae\u00af\u0003N\'\u0000\u00af\u00b0"+
"\u0005\'\u0000\u0000\u00b0\u00b2\u0001\u0000\u0000\u0000\u00b1\u00ac\u0001"+
"\u0000\u0000\u0000\u00b1\u00ad\u0001\u0000\u0000\u0000\u00b1\u00ae\u0001"+
"\u0000\u0000\u0000\u00b2\u0001\u0001\u0000\u0000\u0000\u00b3\u00b6\u0005"+
"\'\u0000\u0000\u00b4\u00b6\u0003\u001a\r\u0000\u00b5\u00b3\u0001\u0000"+
"\u0000\u0000\u00b5\u00b4\u0001\u0000\u0000\u0000\u00b6\u00b9\u0001\u0000"+
"\u0000\u0000\u00b7\u00b5\u0001\u0000\u0000\u0000\u00b7\u00b8\u0001\u0000"+
"\u0000\u0000\u00b8\u00ba\u0001\u0000\u0000\u0000\u00b9\u00b7\u0001\u0000"+
"\u0000\u0000\u00ba\u00bb\u0005\u0000\u0000\u0001\u00bb\u0003\u0001\u0000"+
"\u0000\u0000\u00bc\u00c0\u0003\u0096K\u0000\u00bd\u00bf\u0005\'\u0000"+
"\u0000\u00be\u00bd\u0001\u0000\u0000\u0000\u00bf\u00c2\u0001\u0000\u0000"+
"\u0000\u00c0\u00be\u0001\u0000\u0000\u0000\u00c0\u00c1\u0001\u0000\u0000"+
"\u0000\u00c1\u00c3\u0001\u0000\u0000\u0000\u00c2\u00c0\u0001\u0000\u0000"+
"\u0000\u00c3\u00c4\u0005\u0000\u0000\u0001\u00c4\u0005\u0001\u0000\u0000"+
"\u0000\u00c5\u00c6\u0005Q\u0000\u0000\u00c6\u00cc\u0003F#\u0000\u00c7"+
"\u00c9\u00054\u0000\u0000\u00c8\u00ca\u0003\u009cN\u0000\u00c9\u00c8\u0001"+
"\u0000\u0000\u0000\u00c9\u00ca\u0001\u0000\u0000\u0000\u00ca\u00cb\u0001"+
"\u0000\u0000\u0000\u00cb\u00cd\u00055\u0000\u0000\u00cc\u00c7\u0001\u0000"+
"\u0000\u0000\u00cc\u00cd\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000"+
"\u0000\u0000\u00ce\u00cf\u0005\'\u0000\u0000\u00cf\u0007\u0001\u0000\u0000"+
"\u0000\u00d0\u00d2\u0003\u0006\u0003\u0000\u00d1\u00d0\u0001\u0000\u0000"+
"\u0000\u00d2\u00d3\u0001\u0000\u0000\u0000\u00d3\u00d1\u0001\u0000\u0000"+
"\u0000\u00d3\u00d4\u0001\u0000\u0000\u0000\u00d4\t\u0001\u0000\u0000\u0000"+
"\u00d5\u00d9\u0003\b\u0004\u0000\u00d6\u00da\u0003\u009aM\u0000\u00d7"+
"\u00da\u0003\u000e\u0007\u0000\u00d8\u00da\u0003\f\u0006\u0000\u00d9\u00d6"+
"\u0001\u0000\u0000\u0000\u00d9\u00d7\u0001\u0000\u0000\u0000\u00d9\u00d8"+
"\u0001\u0000\u0000\u0000\u00da\u000b\u0001\u0000\u0000\u0000\u00db\u00dc"+
"\u0005%\u0000\u0000\u00dc\u00dd\u0003\u000e\u0007\u0000\u00dd\r\u0001"+
"\u0000\u0000\u0000\u00de\u00df\u0005\u0004\u0000\u0000\u00df\u00e0\u0005"+
"(\u0000\u0000\u00e0\u00e3\u0003\u0010\b\u0000\u00e1\u00e2\u0005R\u0000"+
"\u0000\u00e2\u00e4\u0003b1\u0000\u00e3\u00e1\u0001\u0000\u0000\u0000\u00e3"+
"\u00e4\u0001\u0000\u0000\u0000\u00e4\u00e5\u0001\u0000\u0000\u0000\u00e5"+
"\u00e6\u00057\u0000\u0000\u00e6\u00e7\u0003`0\u0000\u00e7\u000f\u0001"+
"\u0000\u0000\u0000\u00e8\u00ea\u00054\u0000\u0000\u00e9\u00eb\u0003\u0012"+
"\t\u0000\u00ea\u00e9\u0001\u0000\u0000\u0000\u00ea\u00eb\u0001\u0000\u0000"+
"\u0000\u00eb\u00ec\u0001\u0000\u0000\u0000\u00ec\u00ed\u00055\u0000\u0000"+
"\u00ed\u0011\u0001\u0000\u0000\u0000\u00ee\u00f1\u0003\u0014\n\u0000\u00ef"+
"\u00f0\u0005:\u0000\u0000\u00f0\u00f2\u0003b1\u0000\u00f1\u00ef\u0001"+
"\u0000\u0000\u0000\u00f1\u00f2\u0001\u0000\u0000\u0000\u00f2\u00fb\u0001"+
"\u0000\u0000\u0000\u00f3\u00f4\u00056\u0000\u0000\u00f4\u00f7\u0003\u0014"+
"\n\u0000\u00f5\u00f6\u0005:\u0000\u0000\u00f6\u00f8\u0003b1\u0000\u00f7"+
"\u00f5\u0001\u0000\u0000\u0000\u00f7\u00f8\u0001\u0000\u0000\u0000\u00f8"+
"\u00fa\u0001\u0000\u0000\u0000\u00f9\u00f3\u0001\u0000\u0000\u0000\u00fa"+
"\u00fd\u0001\u0000\u0000\u0000\u00fb\u00f9\u0001\u0000\u0000\u0000\u00fb"+
"\u00fc\u0001\u0000\u0000\u0000\u00fc\u011f\u0001\u0000\u0000\u0000\u00fd"+
"\u00fb\u0001\u0000\u0000\u0000\u00fe\u011d\u00056\u0000\u0000\u00ff\u0101"+
"\u00053\u0000\u0000\u0100\u0102\u0003\u0014\n\u0000\u0101\u0100\u0001"+
"\u0000\u0000\u0000\u0101\u0102\u0001\u0000\u0000\u0000\u0102\u010b\u0001"+
"\u0000\u0000\u0000\u0103\u0104\u00056\u0000\u0000\u0104\u0107\u0003\u0014"+
"\n\u0000\u0105\u0106\u0005:\u0000\u0000\u0106\u0108\u0003b1\u0000\u0107"+
"\u0105\u0001\u0000\u0000\u0000\u0107\u0108\u0001\u0000\u0000\u0000\u0108"+
"\u010a\u0001\u0000\u0000\u0000\u0109\u0103\u0001\u0000\u0000\u0000\u010a"+
"\u010d\u0001\u0000\u0000\u0000\u010b\u0109\u0001\u0000\u0000\u0000\u010b"+
"\u010c\u0001\u0000\u0000\u0000\u010c\u0116\u0001\u0000\u0000\u0000\u010d"+
"\u010b\u0001\u0000\u0000\u0000\u010e\u0114\u00056\u0000\u0000\u010f\u0110"+
"\u00059\u0000\u0000\u0110\u0112\u0003\u0014\n\u0000\u0111\u0113\u0005"+
"6\u0000\u0000\u0112\u0111\u0001\u0000\u0000\u0000\u0112\u0113\u0001\u0000"+
"\u0000\u0000\u0113\u0115\u0001\u0000\u0000\u0000\u0114\u010f\u0001\u0000"+
"\u0000\u0000\u0114\u0115\u0001\u0000\u0000\u0000\u0115\u0117\u0001\u0000"+
"\u0000\u0000\u0116\u010e\u0001\u0000\u0000\u0000\u0116\u0117\u0001\u0000"+
"\u0000\u0000\u0117\u011e\u0001\u0000\u0000\u0000\u0118\u0119\u00059\u0000"+
"\u0000\u0119\u011b\u0003\u0014\n\u0000\u011a\u011c\u00056\u0000\u0000"+
"\u011b\u011a\u0001\u0000\u0000\u0000\u011b\u011c\u0001\u0000\u0000\u0000"+
"\u011c\u011e\u0001\u0000\u0000\u0000\u011d\u00ff\u0001\u0000\u0000\u0000"+
"\u011d\u0118\u0001\u0000\u0000\u0000\u011d\u011e\u0001\u0000\u0000\u0000"+
"\u011e\u0120\u0001\u0000\u0000\u0000\u011f\u00fe\u0001\u0000\u0000\u0000"+
"\u011f\u0120\u0001\u0000\u0000\u0000\u0120\u0140\u0001\u0000\u0000\u0000"+
"\u0121\u0123\u00053\u0000\u0000\u0122\u0124\u0003\u0014\n\u0000\u0123"+
"\u0122\u0001\u0000\u0000\u0000\u0123\u0124\u0001\u0000\u0000\u0000\u0124"+
"\u012d\u0001\u0000\u0000\u0000\u0125\u0126\u00056\u0000\u0000\u0126\u0129"+
"\u0003\u0014\n\u0000\u0127\u0128\u0005:\u0000\u0000\u0128\u012a\u0003"+
"b1\u0000\u0129\u0127\u0001\u0000\u0000\u0000\u0129\u012a\u0001\u0000\u0000"+
"\u0000\u012a\u012c\u0001\u0000\u0000\u0000\u012b\u0125\u0001\u0000\u0000"+
"\u0000\u012c\u012f\u0001\u0000\u0000\u0000\u012d\u012b\u0001\u0000\u0000"+
"\u0000\u012d\u012e\u0001\u0000\u0000\u0000\u012e\u0138\u0001\u0000\u0000"+
"\u0000\u012f\u012d\u0001\u0000\u0000\u0000\u0130\u0136\u00056\u0000\u0000"+
"\u0131\u0132\u00059\u0000\u0000\u0132\u0134\u0003\u0014\n\u0000\u0133"+
"\u0135\u00056\u0000\u0000\u0134\u0133\u0001\u0000\u0000\u0000\u0134\u0135"+
"\u0001\u0000\u0000\u0000\u0135\u0137\u0001\u0000\u0000\u0000\u0136\u0131"+
"\u0001\u0000\u0000\u0000\u0136\u0137\u0001\u0000\u0000\u0000\u0137\u0139"+
"\u0001\u0000\u0000\u0000\u0138\u0130\u0001\u0000\u0000\u0000\u0138\u0139"+
"\u0001\u0000\u0000\u0000\u0139\u0140\u0001\u0000\u0000\u0000\u013a\u013b"+
"\u00059\u0000\u0000\u013b\u013d\u0003\u0014\n\u0000\u013c\u013e\u0005"+
"6\u0000\u0000\u013d\u013c\u0001\u0000\u0000\u0000\u013d\u013e\u0001\u0000"+
"\u0000\u0000\u013e\u0140\u0001\u0000\u0000\u0000\u013f\u00ee\u0001\u0000"+
"\u0000\u0000\u013f\u0121\u0001\u0000\u0000\u0000\u013f\u013a\u0001\u0000"+
"\u0000\u0000\u0140\u0013\u0001\u0000\u0000\u0000\u0141\u0144\u0005(\u0000"+
"\u0000\u0142\u0143\u00057\u0000\u0000\u0143\u0145\u0003b1\u0000\u0144"+
"\u0142\u0001\u0000\u0000\u0000\u0144\u0145\u0001\u0000\u0000\u0000\u0145"+
"\u0015\u0001\u0000\u0000\u0000\u0146\u0149\u0003\u0018\f\u0000\u0147\u0148"+
"\u0005:\u0000\u0000\u0148\u014a\u0003b1\u0000\u0149\u0147\u0001\u0000"+
"\u0000\u0000\u0149\u014a\u0001\u0000\u0000\u0000\u014a\u0153\u0001\u0000"+
"\u0000\u0000\u014b\u014c\u00056\u0000\u0000\u014c\u014f\u0003\u0018\f"+
"\u0000\u014d\u014e\u0005:\u0000\u0000\u014e\u0150\u0003b1\u0000\u014f"+
"\u014d\u0001\u0000\u0000\u0000\u014f\u0150\u0001\u0000\u0000\u0000\u0150"+
"\u0152\u0001\u0000\u0000\u0000\u0151\u014b\u0001\u0000\u0000\u0000\u0152"+
"\u0155\u0001\u0000\u0000\u0000\u0153\u0151\u0001\u0000\u0000\u0000\u0153"+
"\u0154\u0001\u0000\u0000\u0000\u0154\u0177\u0001\u0000\u0000\u0000\u0155"+
"\u0153\u0001\u0000\u0000\u0000\u0156\u0175\u00056\u0000\u0000\u0157\u0159"+
"\u00053\u0000\u0000\u0158\u015a\u0003\u0018\f\u0000\u0159\u0158\u0001"+
"\u0000\u0000\u0000\u0159\u015a\u0001\u0000\u0000\u0000\u015a\u0163\u0001"+
"\u0000\u0000\u0000\u015b\u015c\u00056\u0000\u0000\u015c\u015f\u0003\u0018"+
"\f\u0000\u015d\u015e\u0005:\u0000\u0000\u015e\u0160\u0003b1\u0000\u015f"+
"\u015d\u0001\u0000\u0000\u0000\u015f\u0160\u0001\u0000\u0000\u0000\u0160"+
"\u0162\u0001\u0000\u0000\u0000\u0161\u015b\u0001\u0000\u0000\u0000\u0162"+
"\u0165\u0001\u0000\u0000\u0000\u0163\u0161\u0001\u0000\u0000\u0000\u0163"+
"\u0164\u0001\u0000\u0000\u0000\u0164\u016e\u0001\u0000\u0000\u0000\u0165"+
"\u0163\u0001\u0000\u0000\u0000\u0166\u016c\u00056\u0000\u0000\u0167\u0168"+
"\u00059\u0000\u0000\u0168\u016a\u0003\u0018\f\u0000\u0169\u016b\u0005"+
"6\u0000\u0000\u016a\u0169\u0001\u0000\u0000\u0000\u016a\u016b\u0001\u0000"+
"\u0000\u0000\u016b\u016d\u0001\u0000\u0000\u0000\u016c\u0167\u0001\u0000"+
"\u0000\u0000\u016c\u016d\u0001\u0000\u0000\u0000\u016d\u016f\u0001\u0000"+
"\u0000\u0000\u016e\u0166\u0001\u0000\u0000\u0000\u016e\u016f\u0001\u0000"+
"\u0000\u0000\u016f\u0176\u0001\u0000\u0000\u0000\u0170\u0171\u00059\u0000"+
"\u0000\u0171\u0173\u0003\u0018\f\u0000\u0172\u0174\u00056\u0000\u0000"+
"\u0173\u0172\u0001\u0000\u0000\u0000\u0173\u0174\u0001\u0000\u0000\u0000"+
"\u0174\u0176\u0001\u0000\u0000\u0000\u0175\u0157\u0001\u0000\u0000\u0000"+
"\u0175\u0170\u0001\u0000\u0000\u0000\u0175\u0176\u0001\u0000\u0000\u0000"+
"\u0176\u0178\u0001\u0000\u0000\u0000\u0177\u0156\u0001\u0000\u0000\u0000"+
"\u0177\u0178\u0001\u0000\u0000\u0000\u0178\u0198\u0001\u0000\u0000\u0000"+
"\u0179\u017b\u00053\u0000\u0000\u017a\u017c\u0003\u0018\f\u0000\u017b"+
"\u017a\u0001\u0000\u0000\u0000\u017b\u017c\u0001\u0000\u0000\u0000\u017c"+
"\u0185\u0001\u0000\u0000\u0000\u017d\u017e\u00056\u0000\u0000\u017e\u0181"+
"\u0003\u0018\f\u0000\u017f\u0180\u0005:\u0000\u0000\u0180\u0182\u0003"+
"b1\u0000\u0181\u017f\u0001\u0000\u0000\u0000\u0181\u0182\u0001\u0000\u0000"+
"\u0000\u0182\u0184\u0001\u0000\u0000\u0000\u0183\u017d\u0001\u0000\u0000"+
"\u0000\u0184\u0187\u0001\u0000\u0000\u0000\u0185\u0183\u0001\u0000\u0000"+
"\u0000\u0185\u0186\u0001\u0000\u0000\u0000\u0186\u0190\u0001\u0000\u0000"+
"\u0000\u0187\u0185\u0001\u0000\u0000\u0000\u0188\u018e\u00056\u0000\u0000"+
"\u0189\u018a\u00059\u0000\u0000\u018a\u018c\u0003\u0018\f\u0000\u018b"+
"\u018d\u00056\u0000\u0000\u018c\u018b\u0001\u0000\u0000\u0000\u018c\u018d"+
"\u0001\u0000\u0000\u0000\u018d\u018f\u0001\u0000\u0000\u0000\u018e\u0189"+
"\u0001\u0000\u0000\u0000\u018e\u018f\u0001\u0000\u0000\u0000\u018f\u0191"+
"\u0001\u0000\u0000\u0000\u0190\u0188\u0001\u0000\u0000\u0000\u0190\u0191"+
"\u0001\u0000\u0000\u0000\u0191\u0198\u0001\u0000\u0000\u0000\u0192\u0193"+
"\u00059\u0000\u0000\u0193\u0195\u0003\u0018\f\u0000\u0194\u0196\u0005"+
"6\u0000\u0000\u0195\u0194\u0001\u0000\u0000\u0000\u0195\u0196\u0001\u0000"+
"\u0000\u0000\u0196\u0198\u0001\u0000\u0000\u0000\u0197\u0146\u0001\u0000"+
"\u0000\u0000\u0197\u0179\u0001\u0000\u0000\u0000\u0197\u0192\u0001\u0000"+
"\u0000\u0000\u0198\u0017\u0001\u0000\u0000\u0000\u0199\u019a\u0005(\u0000"+
"\u0000\u019a\u0019\u0001\u0000\u0000\u0000\u019b\u019e\u0003\u001c\u000e"+
"\u0000\u019c\u019e\u0003N\'\u0000\u019d\u019b\u0001\u0000\u0000\u0000"+
"\u019d\u019c\u0001\u0000\u0000\u0000\u019e\u001b\u0001\u0000\u0000\u0000"+
"\u019f\u01a4\u0003\u001e\u000f\u0000\u01a0\u01a1\u00058\u0000\u0000\u01a1"+
"\u01a3\u0003\u001e\u000f\u0000\u01a2\u01a0\u0001\u0000\u0000\u0000\u01a3"+
"\u01a6\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001\u0000\u0000\u0000\u01a4"+
"\u01a5\u0001\u0000\u0000\u0000\u01a5\u01a8\u0001\u0000\u0000\u0000\u01a6"+
"\u01a4\u0001\u0000\u0000\u0000\u01a7\u01a9\u00058\u0000\u0000\u01a8\u01a7"+
"\u0001\u0000\u0000\u0000\u01a8\u01a9\u0001\u0000\u0000\u0000\u01a9\u01aa"+
"\u0001\u0000\u0000\u0000\u01aa\u01ab\u0005\'\u0000\u0000\u01ab\u001d\u0001"+
"\u0000\u0000\u0000\u01ac\u01b5\u0003 \u0010\u0000\u01ad\u01b5\u0003(\u0014"+
"\u0000\u01ae\u01b5\u0003*\u0015\u0000\u01af\u01b5\u0003,\u0016\u0000\u01b0"+
"\u01b5\u00038\u001c\u0000\u01b1\u01b5\u0003H$\u0000\u01b2\u01b5\u0003"+
"J%\u0000\u01b3\u01b5\u0003L&\u0000\u01b4\u01ac\u0001\u0000\u0000\u0000"+
"\u01b4\u01ad\u0001\u0000\u0000\u0000\u01b4\u01ae\u0001\u0000\u0000\u0000"+
"\u01b4\u01af\u0001\u0000\u0000\u0000\u01b4\u01b0\u0001\u0000\u0000\u0000"+
"\u01b4\u01b1\u0001\u0000\u0000\u0000\u01b4\u01b2\u0001\u0000\u0000\u0000"+
"\u01b4\u01b3\u0001\u0000\u0000\u0000\u01b5\u001f\u0001\u0000\u0000\u0000"+
"\u01b6\u01c7\u0003$\u0012\u0000\u01b7\u01c8\u0003\"\u0011\u0000\u01b8"+
"\u01bb\u0003&\u0013\u0000\u01b9\u01bc\u0003\u00a8T\u0000\u01ba\u01bc\u0003"+
"\u0096K\u0000\u01bb\u01b9\u0001\u0000\u0000\u0000\u01bb\u01ba\u0001\u0000"+
"\u0000\u0000\u01bc\u01c8\u0001\u0000\u0000\u0000\u01bd\u01c0\u0005:\u0000"+
"\u0000\u01be\u01c1\u0003\u00a8T\u0000\u01bf\u01c1\u0003$\u0012\u0000\u01c0"+
"\u01be\u0001\u0000\u0000\u0000\u01c0\u01bf\u0001\u0000\u0000\u0000\u01c1"+
"\u01c3\u0001\u0000\u0000\u0000\u01c2\u01bd\u0001\u0000\u0000\u0000\u01c3"+
"\u01c6\u0001\u0000\u0000\u0000\u01c4\u01c2\u0001\u0000\u0000\u0000\u01c4"+
"\u01c5\u0001\u0000\u0000\u0000\u01c5\u01c8\u0001\u0000\u0000\u0000\u01c6"+
"\u01c4\u0001\u0000\u0000\u0000\u01c7\u01b7\u0001\u0000\u0000\u0000\u01c7"+
"\u01b8\u0001\u0000\u0000\u0000\u01c7\u01c4\u0001\u0000\u0000\u0000\u01c8"+
"!\u0001\u0000\u0000\u0000\u01c9\u01ca\u00057\u0000\u0000\u01ca\u01cd\u0003"+
"b1\u0000\u01cb\u01cc\u0005:\u0000\u0000\u01cc\u01ce\u0003b1\u0000\u01cd"+
"\u01cb\u0001\u0000\u0000\u0000\u01cd\u01ce\u0001\u0000\u0000\u0000\u01ce"+
"#\u0001\u0000\u0000\u0000\u01cf\u01d2\u0003b1\u0000\u01d0\u01d2\u0003"+
"t:\u0000\u01d1\u01cf\u0001\u0000\u0000\u0000\u01d1\u01d0\u0001\u0000\u0000"+
"\u0000\u01d2\u01da\u0001\u0000\u0000\u0000\u01d3\u01d6\u00056\u0000\u0000"+
"\u01d4\u01d7\u0003b1\u0000\u01d5\u01d7\u0003t:\u0000\u01d6\u01d4\u0001"+
"\u0000\u0000\u0000\u01d6\u01d5\u0001\u0000\u0000\u0000\u01d7\u01d9\u0001"+
"\u0000\u0000\u0000\u01d8\u01d3\u0001\u0000\u0000\u0000\u01d9\u01dc\u0001"+
"\u0000\u0000\u0000\u01da\u01d8\u0001\u0000\u0000\u0000\u01da\u01db\u0001"+
"\u0000\u0000\u0000\u01db\u01de\u0001\u0000\u0000\u0000\u01dc\u01da\u0001"+
"\u0000\u0000\u0000\u01dd\u01df\u00056\u0000\u0000\u01de\u01dd\u0001\u0000"+
"\u0000\u0000\u01de\u01df\u0001\u0000\u0000\u0000\u01df%\u0001\u0000\u0000"+
"\u0000\u01e0\u01e1\u0007\u0000\u0000\u0000\u01e1\'\u0001\u0000\u0000\u0000"+
"\u01e2\u01e3\u0005!\u0000\u0000\u01e3\u01e4\u0003\u0094J\u0000\u01e4)"+
"\u0001\u0000\u0000\u0000\u01e5\u01e6\u0005\"\u0000\u0000\u01e6+\u0001"+
"\u0000\u0000\u0000\u01e7\u01ed\u0003.\u0017\u0000\u01e8\u01ed\u00030\u0018"+
"\u0000\u01e9\u01ed\u00032\u0019\u0000\u01ea\u01ed\u00036\u001b\u0000\u01eb"+
"\u01ed\u00034\u001a\u0000\u01ec\u01e7\u0001\u0000\u0000\u0000\u01ec\u01e8"+
"\u0001\u0000\u0000\u0000\u01ec\u01e9\u0001\u0000\u0000\u0000\u01ec\u01ea"+
"\u0001\u0000\u0000\u0000\u01ec\u01eb\u0001\u0000\u0000\u0000\u01ed-\u0001"+
"\u0000\u0000\u0000\u01ee\u01ef\u0005$\u0000\u0000\u01ef/\u0001\u0000\u0000"+
"\u0000\u01f0\u01f1\u0005#\u0000\u0000\u01f11\u0001\u0000\u0000\u0000\u01f2"+
"\u01f4\u0005\u0005\u0000\u0000\u01f3\u01f5\u0003\u0096K\u0000\u01f4\u01f3"+
"\u0001\u0000\u0000\u0000\u01f4\u01f5\u0001\u0000\u0000\u0000\u01f53\u0001"+
"\u0000\u0000\u0000\u01f6\u01f7\u0003\u00a8T\u0000\u01f75\u0001\u0000\u0000"+
"\u0000\u01f8\u01fe\u0005\u0006\u0000\u0000\u01f9\u01fc\u0003b1\u0000\u01fa"+
"\u01fb\u0005\u0007\u0000\u0000\u01fb\u01fd\u0003b1\u0000\u01fc\u01fa\u0001"+
"\u0000\u0000\u0000\u01fc\u01fd\u0001\u0000\u0000\u0000\u01fd\u01ff\u0001"+
"\u0000\u0000\u0000\u01fe\u01f9\u0001\u0000\u0000\u0000\u01fe\u01ff\u0001"+
"\u0000\u0000\u0000\u01ff7\u0001\u0000\u0000\u0000\u0200\u0203\u0003:\u001d"+
"\u0000\u0201\u0203\u0003<\u001e\u0000\u0202\u0200\u0001\u0000\u0000\u0000"+
"\u0202\u0201\u0001\u0000\u0000\u0000\u02039\u0001\u0000\u0000\u0000\u0204"+
"\u0205\u0005\b\u0000\u0000\u0205\u0206\u0003D\"\u0000\u0206;\u0001\u0000"+
"\u0000\u0000\u0207\u0214\u0005\u0007\u0000\u0000\u0208\u020a\u0007\u0001"+
"\u0000\u0000\u0209\u0208\u0001\u0000\u0000\u0000\u020a\u020d\u0001\u0000"+
"\u0000\u0000\u020b\u0209\u0001\u0000\u0000\u0000\u020b\u020c\u0001\u0000"+
"\u0000\u0000\u020c\u020e\u0001\u0000\u0000\u0000\u020d\u020b\u0001\u0000"+
"\u0000\u0000\u020e\u0215\u0003F#\u0000\u020f\u0211\u0007\u0001\u0000\u0000"+
"\u0210\u020f\u0001\u0000\u0000\u0000\u0211\u0212\u0001\u0000\u0000\u0000"+
"\u0212\u0210\u0001\u0000\u0000\u0000\u0212\u0213\u0001\u0000\u0000\u0000"+
"\u0213\u0215\u0001\u0000\u0000\u0000\u0214\u020b\u0001\u0000\u0000\u0000"+
"\u0214\u0210\u0001\u0000\u0000\u0000\u0215\u0216\u0001\u0000\u0000\u0000"+
"\u0216\u021d\u0005\b\u0000\u0000\u0217\u021e\u00053\u0000\u0000\u0218"+
"\u0219\u00054\u0000\u0000\u0219\u021a\u0003B!\u0000\u021a\u021b\u0005"+
"5\u0000\u0000\u021b\u021e\u0001\u0000\u0000\u0000\u021c\u021e\u0003B!"+
"\u0000\u021d\u0217\u0001\u0000\u0000\u0000\u021d\u0218\u0001\u0000\u0000"+
"\u0000\u021d\u021c\u0001\u0000\u0000\u0000\u021e=\u0001\u0000\u0000\u0000"+
"\u021f\u0222\u0005(\u0000\u0000\u0220\u0221\u0005\t\u0000\u0000\u0221"+
"\u0223\u0005(\u0000\u0000\u0222\u0220\u0001\u0000\u0000\u0000\u0222\u0223"+
"\u0001\u0000\u0000\u0000\u0223?\u0001\u0000\u0000\u0000\u0224\u0227\u0003"+
"F#\u0000\u0225\u0226\u0005\t\u0000\u0000\u0226\u0228\u0005(\u0000\u0000"+
"\u0227\u0225\u0001\u0000\u0000\u0000\u0227\u0228\u0001\u0000\u0000\u0000"+
"\u0228A\u0001\u0000\u0000\u0000\u0229\u022e\u0003>\u001f\u0000\u022a\u022b"+
"\u00056\u0000\u0000\u022b\u022d\u0003>\u001f\u0000\u022c\u022a\u0001\u0000"+
"\u0000\u0000\u022d\u0230\u0001\u0000\u0000\u0000\u022e\u022c\u0001\u0000"+
"\u0000\u0000\u022e\u022f\u0001\u0000\u0000\u0000\u022f\u0232\u0001\u0000"+
"\u0000\u0000\u0230\u022e\u0001\u0000\u0000\u0000\u0231\u0233\u00056\u0000"+
"\u0000\u0232\u0231\u0001\u0000\u0000\u0000\u0232\u0233\u0001\u0000\u0000"+
"\u0000\u0233C\u0001\u0000\u0000\u0000\u0234\u0239\u0003@ \u0000\u0235"+
"\u0236\u00056\u0000\u0000\u0236\u0238\u0003@ \u0000\u0237\u0235\u0001"+
"\u0000\u0000\u0000\u0238\u023b\u0001\u0000\u0000\u0000\u0239\u0237\u0001"+
"\u0000\u0000\u0000\u0239\u023a\u0001\u0000\u0000\u0000\u023aE\u0001\u0000"+
"\u0000\u0000\u023b\u0239\u0001\u0000\u0000\u0000\u023c\u0241\u0005(\u0000"+
"\u0000\u023d\u023e\u00051\u0000\u0000\u023e\u0240\u0005(\u0000\u0000\u023f"+
"\u023d\u0001\u0000\u0000\u0000\u0240\u0243\u0001\u0000\u0000\u0000\u0241"+
"\u023f\u0001\u0000\u0000\u0000\u0241\u0242\u0001\u0000\u0000\u0000\u0242"+
"G\u0001\u0000\u0000\u0000\u0243\u0241\u0001\u0000\u0000\u0000\u0244\u0245"+
"\u0005\n\u0000\u0000\u0245\u024a\u0005(\u0000\u0000\u0246\u0247\u0005"+
"6\u0000\u0000\u0247\u0249\u0005(\u0000\u0000\u0248\u0246\u0001\u0000\u0000"+
"\u0000\u0249\u024c\u0001\u0000\u0000\u0000\u024a\u0248\u0001\u0000\u0000"+
"\u0000\u024a\u024b\u0001\u0000\u0000\u0000\u024bI\u0001\u0000\u0000\u0000"+
"\u024c\u024a\u0001\u0000\u0000\u0000\u024d\u024e\u0005\u000b\u0000\u0000"+
"\u024e\u0253\u0005(\u0000\u0000\u024f\u0250\u00056\u0000\u0000\u0250\u0252"+
"\u0005(\u0000\u0000\u0251\u024f\u0001\u0000\u0000\u0000\u0252\u0255\u0001"+
"\u0000\u0000\u0000\u0253\u0251\u0001\u0000\u0000\u0000\u0253\u0254\u0001"+
"\u0000\u0000\u0000\u0254K\u0001\u0000\u0000\u0000\u0255\u0253\u0001\u0000"+
"\u0000\u0000\u0256\u0257\u0005\f\u0000\u0000\u0257\u025a\u0003b1\u0000"+
"\u0258\u0259\u00056\u0000\u0000\u0259\u025b\u0003b1\u0000\u025a\u0258"+
"\u0001\u0000\u0000\u0000\u025a\u025b\u0001\u0000\u0000\u0000\u025bM\u0001"+
"\u0000\u0000\u0000\u025c\u0266\u0003R)\u0000\u025d\u0266\u0003T*\u0000"+
"\u025e\u0266\u0003V+\u0000\u025f\u0266\u0003X,\u0000\u0260\u0266\u0003"+
"Z-\u0000\u0261\u0266\u0003\u000e\u0007\u0000\u0262\u0266\u0003\u009aM"+
"\u0000\u0263\u0266\u0003\n\u0005\u0000\u0264\u0266\u0003P(\u0000\u0265"+
"\u025c\u0001\u0000\u0000\u0000\u0265\u025d\u0001\u0000\u0000\u0000\u0265"+
"\u025e\u0001\u0000\u0000\u0000\u0265\u025f\u0001\u0000\u0000\u0000\u0265"+
"\u0260\u0001\u0000\u0000\u0000\u0265\u0261\u0001\u0000\u0000\u0000\u0265"+
"\u0262\u0001\u0000\u0000\u0000\u0265\u0263\u0001\u0000\u0000\u0000\u0265"+
"\u0264\u0001\u0000\u0000\u0000\u0266O\u0001\u0000\u0000\u0000\u0267\u026b"+
"\u0005%\u0000\u0000\u0268\u026c\u0003\u000e\u0007\u0000\u0269\u026c\u0003"+
"Z-\u0000\u026a\u026c\u0003V+\u0000\u026b\u0268\u0001\u0000\u0000\u0000"+
"\u026b\u0269\u0001\u0000\u0000\u0000\u026b\u026a\u0001\u0000\u0000\u0000"+
"\u026cQ\u0001\u0000\u0000\u0000\u026d\u026e\u0005\r\u0000\u0000\u026e"+
"\u026f\u0003b1\u0000\u026f\u0270\u00057\u0000\u0000\u0270\u0278\u0003"+
"`0\u0000\u0271\u0272\u0005\u000e\u0000\u0000\u0272\u0273\u0003b1\u0000"+
"\u0273\u0274\u00057\u0000\u0000\u0274\u0275\u0003`0\u0000\u0275\u0277"+
"\u0001\u0000\u0000\u0000\u0276\u0271\u0001\u0000\u0000\u0000\u0277\u027a"+
"\u0001\u0000\u0000\u0000\u0278\u0276\u0001\u0000\u0000\u0000\u0278\u0279"+
"\u0001\u0000\u0000\u0000\u0279\u027e\u0001\u0000\u0000\u0000\u027a\u0278"+
"\u0001\u0000\u0000\u0000\u027b\u027c\u0005\u000f\u0000\u0000\u027c\u027d"+
"\u00057\u0000\u0000\u027d\u027f\u0003`0\u0000\u027e\u027b\u0001\u0000"+
"\u0000\u0000\u027e\u027f\u0001\u0000\u0000\u0000\u027fS\u0001\u0000\u0000"+
"\u0000\u0280\u0281\u0005\u0010\u0000\u0000\u0281\u0282\u0003b1\u0000\u0282"+
"\u0283\u00057\u0000\u0000\u0283\u0287\u0003`0\u0000\u0284\u0285\u0005"+
"\u000f\u0000\u0000\u0285\u0286\u00057\u0000\u0000\u0286\u0288\u0003`0"+
"\u0000\u0287\u0284\u0001\u0000\u0000\u0000\u0287\u0288\u0001\u0000\u0000"+
"\u0000\u0288U\u0001\u0000\u0000\u0000\u0289\u028a\u0005\u0011\u0000\u0000"+
"\u028a\u028b\u0003\u0094J\u0000\u028b\u028c\u0005\u0012\u0000\u0000\u028c"+
"\u028d\u0003\u0096K\u0000\u028d\u028e\u00057\u0000\u0000\u028e\u0292\u0003"+
"`0\u0000\u028f\u0290\u0005\u000f\u0000\u0000\u0290\u0291\u00057\u0000"+
"\u0000\u0291\u0293\u0003`0\u0000\u0292\u028f\u0001\u0000\u0000\u0000\u0292"+
"\u0293\u0001\u0000\u0000\u0000\u0293W\u0001\u0000\u0000\u0000\u0294\u0295"+
"\u0005\u0013\u0000\u0000\u0295\u0296\u00057\u0000\u0000\u0296\u02ac\u0003"+
"`0\u0000\u0297\u0298\u0003^/\u0000\u0298\u0299\u00057\u0000\u0000\u0299"+
"\u029a\u0003`0\u0000\u029a\u029c\u0001\u0000\u0000\u0000\u029b\u0297\u0001"+
"\u0000\u0000\u0000\u029c\u029d\u0001\u0000\u0000\u0000\u029d\u029b\u0001"+
"\u0000\u0000\u0000\u029d\u029e\u0001\u0000\u0000\u0000\u029e\u02a2\u0001"+
"\u0000\u0000\u0000\u029f\u02a0\u0005\u000f\u0000\u0000\u02a0\u02a1\u0005"+
"7\u0000\u0000\u02a1\u02a3\u0003`0\u0000\u02a2\u029f\u0001\u0000\u0000"+
"\u0000\u02a2\u02a3\u0001\u0000\u0000\u0000\u02a3\u02a7\u0001\u0000\u0000"+
"\u0000\u02a4\u02a5\u0005\u0014\u0000\u0000\u02a5\u02a6\u00057\u0000\u0000"+
"\u02a6\u02a8\u0003`0\u0000\u02a7\u02a4\u0001\u0000\u0000\u0000\u02a7\u02a8"+
"\u0001\u0000\u0000\u0000\u02a8\u02ad\u0001\u0000\u0000\u0000\u02a9\u02aa"+
"\u0005\u0014\u0000\u0000\u02aa\u02ab\u00057\u0000\u0000\u02ab\u02ad\u0003"+
"`0\u0000\u02ac\u029b\u0001\u0000\u0000\u0000\u02ac\u02a9\u0001\u0000\u0000"+
"\u0000\u02adY\u0001\u0000\u0000\u0000\u02ae\u02af\u0005\u0015\u0000\u0000"+
"\u02af\u02b4\u0003\\.\u0000\u02b0\u02b1\u00056\u0000\u0000\u02b1\u02b3"+
"\u0003\\.\u0000\u02b2\u02b0\u0001\u0000\u0000\u0000\u02b3\u02b6\u0001"+
"\u0000\u0000\u0000\u02b4\u02b2\u0001\u0000\u0000\u0000\u02b4\u02b5\u0001"+
"\u0000\u0000\u0000\u02b5\u02b7\u0001\u0000\u0000\u0000\u02b6\u02b4\u0001"+
"\u0000\u0000\u0000\u02b7\u02b8\u00057\u0000\u0000\u02b8\u02b9\u0003`0"+
"\u0000\u02b9[\u0001\u0000\u0000\u0000\u02ba\u02bd\u0003b1\u0000\u02bb"+
"\u02bc\u0005\t\u0000\u0000\u02bc\u02be\u0003v;\u0000\u02bd\u02bb\u0001"+
"\u0000\u0000\u0000\u02bd\u02be\u0001\u0000\u0000\u0000\u02be]\u0001\u0000"+
"\u0000\u0000\u02bf\u02c5\u0005\u0016\u0000\u0000\u02c0\u02c3\u0003b1\u0000"+
"\u02c1\u02c2\u0005\t\u0000\u0000\u02c2\u02c4\u0005(\u0000\u0000\u02c3"+
"\u02c1\u0001\u0000\u0000\u0000\u02c3\u02c4\u0001\u0000\u0000\u0000\u02c4"+
"\u02c6\u0001\u0000\u0000\u0000\u02c5\u02c0\u0001\u0000\u0000\u0000\u02c5"+
"\u02c6\u0001\u0000\u0000\u0000\u02c6_\u0001\u0000\u0000\u0000\u02c7\u02d2"+
"\u0003\u001c\u000e\u0000\u02c8\u02c9\u0005\'\u0000\u0000\u02c9\u02cb\u0005"+
"b\u0000\u0000\u02ca\u02cc\u0003\u001a\r\u0000\u02cb\u02ca\u0001\u0000"+
"\u0000\u0000\u02cc\u02cd\u0001\u0000\u0000\u0000\u02cd\u02cb\u0001\u0000"+
"\u0000\u0000\u02cd\u02ce\u0001\u0000\u0000\u0000\u02ce\u02cf\u0001\u0000"+
"\u0000\u0000\u02cf\u02d0\u0005c\u0000\u0000\u02d0\u02d2\u0001\u0000\u0000"+
"\u0000\u02d1\u02c7\u0001\u0000\u0000\u0000\u02d1\u02c8\u0001\u0000\u0000"+
"\u0000\u02d2a\u0001\u0000\u0000\u0000\u02d3\u02d9\u0003j5\u0000\u02d4"+
"\u02d5\u0005\r\u0000\u0000\u02d5\u02d6\u0003j5\u0000\u02d6\u02d7\u0005"+
"\u000f\u0000\u0000\u02d7\u02d8\u0003b1\u0000\u02d8\u02da\u0001\u0000\u0000"+
"\u0000\u02d9\u02d4\u0001\u0000\u0000\u0000\u02d9\u02da\u0001\u0000\u0000"+
"\u0000\u02da\u02dd\u0001\u0000\u0000\u0000\u02db\u02dd\u0003f3\u0000\u02dc"+
"\u02d3\u0001\u0000\u0000\u0000\u02dc\u02db\u0001\u0000\u0000\u0000\u02dd"+
"c\u0001\u0000\u0000\u0000\u02de\u02e1\u0003j5\u0000\u02df\u02e1\u0003"+
"h4\u0000\u02e0\u02de\u0001\u0000\u0000\u0000\u02e0\u02df\u0001\u0000\u0000"+
"\u0000\u02e1e\u0001\u0000\u0000\u0000\u02e2\u02e4\u0005\u0017\u0000\u0000"+
"\u02e3\u02e5\u0003\u0016\u000b\u0000\u02e4\u02e3\u0001\u0000\u0000\u0000"+
"\u02e4\u02e5\u0001\u0000\u0000\u0000\u02e5\u02e6\u0001\u0000\u0000\u0000"+
"\u02e6\u02e7\u00057\u0000\u0000\u02e7\u02e8\u0003b1\u0000\u02e8g\u0001"+
"\u0000\u0000\u0000\u02e9\u02eb\u0005\u0017\u0000\u0000\u02ea\u02ec\u0003"+
"\u0016\u000b\u0000\u02eb\u02ea\u0001\u0000\u0000\u0000\u02eb\u02ec\u0001"+
"\u0000\u0000\u0000\u02ec\u02ed\u0001\u0000\u0000\u0000\u02ed\u02ee\u0005"+
"7\u0000\u0000\u02ee\u02ef\u0003d2\u0000\u02efi\u0001\u0000\u0000\u0000"+
"\u02f0\u02f5\u0003l6\u0000\u02f1\u02f2\u0005\u0018\u0000\u0000\u02f2\u02f4"+
"\u0003l6\u0000\u02f3\u02f1\u0001\u0000\u0000\u0000\u02f4\u02f7\u0001\u0000"+
"\u0000\u0000\u02f5\u02f3\u0001\u0000\u0000\u0000\u02f5\u02f6\u0001\u0000"+
"\u0000\u0000\u02f6k\u0001\u0000\u0000\u0000\u02f7\u02f5\u0001\u0000\u0000"+
"\u0000\u02f8\u02fd\u0003n7\u0000\u02f9\u02fa\u0005\u0019\u0000\u0000\u02fa"+
"\u02fc\u0003n7\u0000\u02fb\u02f9\u0001\u0000\u0000\u0000\u02fc\u02ff\u0001"+
"\u0000\u0000\u0000\u02fd\u02fb\u0001\u0000\u0000\u0000\u02fd\u02fe\u0001"+
"\u0000\u0000\u0000\u02fem\u0001\u0000\u0000\u0000\u02ff\u02fd\u0001\u0000"+
"\u0000\u0000\u0300\u0301\u0005\u001a\u0000\u0000\u0301\u0304\u0003n7\u0000"+
"\u0302\u0304\u0003p8\u0000\u0303\u0300\u0001\u0000\u0000\u0000\u0303\u0302"+
"\u0001\u0000\u0000\u0000\u0304o\u0001\u0000\u0000\u0000\u0305\u030b\u0003"+
"v;\u0000\u0306\u0307\u0003r9\u0000\u0307\u0308\u0003v;\u0000\u0308\u030a"+
"\u0001\u0000\u0000\u0000\u0309\u0306\u0001\u0000\u0000\u0000\u030a\u030d"+
"\u0001\u0000\u0000\u0000\u030b\u0309\u0001\u0000\u0000\u0000\u030b\u030c"+
"\u0001\u0000\u0000\u0000\u030cq\u0001\u0000\u0000\u0000\u030d\u030b\u0001"+
"\u0000\u0000\u0000\u030e\u031c\u0005J\u0000\u0000\u030f\u031c\u0005K\u0000"+
"\u0000\u0310\u031c\u0005L\u0000\u0000\u0311\u031c\u0005M\u0000\u0000\u0312"+
"\u031c\u0005N\u0000\u0000\u0313\u031c\u0005O\u0000\u0000\u0314\u031c\u0005"+
"P\u0000\u0000\u0315\u031c\u0005\u0012\u0000\u0000\u0316\u0317\u0005\u001a"+
"\u0000\u0000\u0317\u031c\u0005\u0012\u0000\u0000\u0318\u031c\u0005\u001b"+
"\u0000\u0000\u0319\u031a\u0005\u001b\u0000\u0000\u031a\u031c\u0005\u001a"+
"\u0000\u0000\u031b\u030e\u0001\u0000\u0000\u0000\u031b\u030f\u0001\u0000"+
"\u0000\u0000\u031b\u0310\u0001\u0000\u0000\u0000\u031b\u0311\u0001\u0000"+
"\u0000\u0000\u031b\u0312\u0001\u0000\u0000\u0000\u031b\u0313\u0001\u0000"+
"\u0000\u0000\u031b\u0314\u0001\u0000\u0000\u0000\u031b\u0315\u0001\u0000"+
"\u0000\u0000\u031b\u0316\u0001\u0000\u0000\u0000\u031b\u0318\u0001\u0000"+
"\u0000\u0000\u031b\u0319\u0001\u0000\u0000\u0000\u031cs\u0001\u0000\u0000"+
"\u0000\u031d\u031e\u00053\u0000\u0000\u031e\u031f\u0003v;\u0000\u031f"+
"u\u0001\u0000\u0000\u0000\u0320\u0325\u0003x<\u0000\u0321\u0322\u0005"+
"=\u0000\u0000\u0322\u0324\u0003x<\u0000\u0323\u0321\u0001\u0000\u0000"+
"\u0000\u0324\u0327\u0001\u0000\u0000\u0000\u0325\u0323\u0001\u0000\u0000"+
"\u0000\u0325\u0326\u0001\u0000\u0000\u0000\u0326w\u0001\u0000\u0000\u0000"+
"\u0327\u0325\u0001\u0000\u0000\u0000\u0328\u032d\u0003z=\u0000\u0329\u032a"+
"\u0005>\u0000\u0000\u032a\u032c\u0003z=\u0000\u032b\u0329\u0001\u0000"+
"\u0000\u0000\u032c\u032f\u0001\u0000\u0000\u0000\u032d\u032b\u0001\u0000"+
"\u0000\u0000\u032d\u032e\u0001\u0000\u0000\u0000\u032ey\u0001\u0000\u0000"+
"\u0000\u032f\u032d\u0001\u0000\u0000\u0000\u0330\u0335\u0003|>\u0000\u0331"+
"\u0332\u0005?\u0000\u0000\u0332\u0334\u0003|>\u0000\u0333\u0331\u0001"+
"\u0000\u0000\u0000\u0334\u0337\u0001\u0000\u0000\u0000\u0335\u0333\u0001"+
"\u0000\u0000\u0000\u0335\u0336\u0001\u0000\u0000\u0000\u0336{\u0001\u0000"+
"\u0000\u0000\u0337\u0335\u0001\u0000\u0000\u0000\u0338\u033d\u0003~?\u0000"+
"\u0339\u033a\u0007\u0002\u0000\u0000\u033a\u033c\u0003~?\u0000\u033b\u0339"+
"\u0001\u0000\u0000\u0000\u033c\u033f\u0001\u0000\u0000\u0000\u033d\u033b"+
"\u0001\u0000\u0000\u0000\u033d\u033e\u0001\u0000\u0000\u0000\u033e}\u0001"+
"\u0000\u0000\u0000\u033f\u033d\u0001\u0000\u0000\u0000\u0340\u0345\u0003"+
"\u0080@\u0000\u0341\u0342\u0007\u0003\u0000\u0000\u0342\u0344\u0003\u0080"+
"@\u0000\u0343\u0341\u0001\u0000\u0000\u0000\u0344\u0347\u0001\u0000\u0000"+
"\u0000\u0345\u0343\u0001\u0000\u0000\u0000\u0345\u0346\u0001\u0000\u0000"+
"\u0000\u0346\u007f\u0001\u0000\u0000\u0000\u0347\u0345\u0001\u0000\u0000"+
"\u0000\u0348\u034d\u0003\u0082A\u0000\u0349\u034a\u0007\u0004\u0000\u0000"+
"\u034a\u034c\u0003\u0082A\u0000\u034b\u0349\u0001\u0000\u0000\u0000\u034c"+
"\u034f\u0001\u0000\u0000\u0000\u034d\u034b\u0001\u0000\u0000\u0000\u034d"+
"\u034e\u0001\u0000\u0000\u0000\u034e\u0081\u0001\u0000\u0000\u0000\u034f"+
"\u034d\u0001\u0000\u0000\u0000\u0350\u0351\u0007\u0005\u0000\u0000\u0351"+
"\u0354\u0003\u0082A\u0000\u0352\u0354\u0003\u0084B\u0000\u0353\u0350\u0001"+
"\u0000\u0000\u0000\u0353\u0352\u0001\u0000\u0000\u0000\u0354\u0083\u0001"+
"\u0000\u0000\u0000\u0355\u0358\u0003\u0086C\u0000\u0356\u0357\u00059\u0000"+
"\u0000\u0357\u0359\u0003\u0082A\u0000\u0358\u0356\u0001\u0000\u0000\u0000"+
"\u0358\u0359\u0001\u0000\u0000\u0000\u0359\u0085\u0001\u0000\u0000\u0000"+
"\u035a\u035c\u0005&\u0000\u0000\u035b\u035a\u0001\u0000\u0000\u0000\u035b"+
"\u035c\u0001\u0000\u0000\u0000\u035c\u035d\u0001\u0000\u0000\u0000\u035d"+
"\u0361\u0003\u0088D\u0000\u035e\u0360\u0003\u008cF\u0000\u035f\u035e\u0001"+
"\u0000\u0000\u0000\u0360\u0363\u0001\u0000\u0000\u0000\u0361\u035f\u0001"+
"\u0000\u0000\u0000\u0361\u0362\u0001\u0000\u0000\u0000\u0362\u0087\u0001"+
"\u0000\u0000\u0000\u0363\u0361\u0001\u0000\u0000\u0000\u0364\u0367\u0005"+
"4\u0000\u0000\u0365\u0368\u0003\u00a8T\u0000\u0366\u0368\u0003\u008aE"+
"\u0000\u0367\u0365\u0001\u0000\u0000\u0000\u0367\u0366\u0001\u0000\u0000"+
"\u0000\u0367\u0368\u0001\u0000\u0000\u0000\u0368\u0369\u0001\u0000\u0000"+
"\u0000\u0369\u0380\u00055\u0000\u0000\u036a\u036c\u0005;\u0000\u0000\u036b"+
"\u036d\u0003\u008aE\u0000\u036c\u036b\u0001\u0000\u0000\u0000\u036c\u036d"+
"\u0001\u0000\u0000\u0000\u036d\u036e\u0001\u0000\u0000\u0000\u036e\u0380"+
"\u0005<\u0000\u0000\u036f\u0371\u0005H\u0000\u0000\u0370\u0372\u0003\u0098"+
"L\u0000\u0371\u0370\u0001\u0000\u0000\u0000\u0371\u0372\u0001\u0000\u0000"+
"\u0000\u0372\u0373\u0001\u0000\u0000\u0000\u0373\u0380\u0005I\u0000\u0000"+
"\u0374\u0380\u0005(\u0000\u0000\u0375\u0380\u0005\u0002\u0000\u0000\u0376"+
"\u0378\u0005\u0001\u0000\u0000\u0377\u0376\u0001\u0000\u0000\u0000\u0378"+
"\u0379\u0001\u0000\u0000\u0000\u0379\u0377\u0001\u0000\u0000\u0000\u0379"+
"\u037a\u0001\u0000\u0000\u0000\u037a\u0380\u0001\u0000\u0000\u0000\u037b"+
"\u0380\u00052\u0000\u0000\u037c\u0380\u0005\u001c\u0000\u0000\u037d\u0380"+
"\u0005\u001d\u0000\u0000\u037e\u0380\u0005\u001e\u0000\u0000\u037f\u0364"+
"\u0001\u0000\u0000\u0000\u037f\u036a\u0001\u0000\u0000\u0000\u037f\u036f"+
"\u0001\u0000\u0000\u0000\u037f\u0374\u0001\u0000\u0000\u0000\u037f\u0375"+
"\u0001\u0000\u0000\u0000\u037f\u0377\u0001\u0000\u0000\u0000\u037f\u037b"+
"\u0001\u0000\u0000\u0000\u037f\u037c\u0001\u0000\u0000\u0000\u037f\u037d"+
"\u0001\u0000\u0000\u0000\u037f\u037e\u0001\u0000\u0000\u0000\u0380\u0089"+
"\u0001\u0000\u0000\u0000\u0381\u0384\u0003b1\u0000\u0382\u0384\u0003t"+
":\u0000\u0383\u0381\u0001\u0000\u0000\u0000\u0383\u0382\u0001\u0000\u0000"+
"\u0000\u0384\u0393\u0001\u0000\u0000\u0000\u0385\u0394\u0003\u00a2Q\u0000"+
"\u0386\u0389\u00056\u0000\u0000\u0387\u038a\u0003b1\u0000\u0388\u038a"+
"\u0003t:\u0000\u0389\u0387\u0001\u0000\u0000\u0000\u0389\u0388\u0001\u0000"+
"\u0000\u0000\u038a\u038c\u0001\u0000\u0000\u0000\u038b\u0386\u0001\u0000"+
"\u0000\u0000\u038c\u038f\u0001\u0000\u0000\u0000\u038d\u038b\u0001\u0000"+
"\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000\u038e\u0391\u0001\u0000"+
"\u0000\u0000\u038f\u038d\u0001\u0000\u0000\u0000\u0390\u0392\u00056\u0000"+
"\u0000\u0391\u0390\u0001\u0000\u0000\u0000\u0391\u0392\u0001\u0000\u0000"+
"\u0000\u0392\u0394\u0001\u0000\u0000\u0000\u0393\u0385\u0001\u0000\u0000"+
"\u0000\u0393\u038d\u0001\u0000\u0000\u0000\u0394\u008b\u0001\u0000\u0000"+
"\u0000\u0395\u0397\u00054\u0000\u0000\u0396\u0398\u0003\u009cN\u0000\u0397"+
"\u0396\u0001\u0000\u0000\u0000\u0397\u0398\u0001\u0000\u0000\u0000\u0398"+
"\u0399\u0001\u0000\u0000\u0000\u0399\u03a1\u00055\u0000\u0000\u039a\u039b"+
"\u0005;\u0000\u0000\u039b\u039c\u0003\u008eG\u0000\u039c\u039d\u0005<"+
"\u0000\u0000\u039d\u03a1\u0001\u0000\u0000\u0000\u039e\u039f\u00051\u0000"+
"\u0000\u039f\u03a1\u0005(\u0000\u0000\u03a0\u0395\u0001\u0000\u0000\u0000"+
"\u03a0\u039a\u0001\u0000\u0000\u0000\u03a0\u039e\u0001\u0000\u0000\u0000"+
"\u03a1\u008d\u0001\u0000\u0000\u0000\u03a2\u03a7\u0003\u0090H\u0000\u03a3"+
"\u03a4\u00056\u0000\u0000\u03a4\u03a6\u0003\u0090H\u0000\u03a5\u03a3\u0001"+
"\u0000\u0000\u0000\u03a6\u03a9\u0001\u0000\u0000\u0000\u03a7\u03a5\u0001"+
"\u0000\u0000\u0000\u03a7\u03a8\u0001\u0000\u0000\u0000\u03a8\u03ab\u0001"+
"\u0000\u0000\u0000\u03a9\u03a7\u0001\u0000\u0000\u0000\u03aa\u03ac\u0005"+
"6\u0000\u0000\u03ab\u03aa\u0001\u0000\u0000\u0000\u03ab\u03ac\u0001\u0000"+
"\u0000\u0000\u03ac\u008f\u0001\u0000\u0000\u0000\u03ad\u03b9\u0003b1\u0000"+
"\u03ae\u03b0\u0003b1\u0000\u03af\u03ae\u0001\u0000\u0000\u0000\u03af\u03b0"+
"\u0001\u0000\u0000\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000\u03b1\u03b3"+
"\u00057\u0000\u0000\u03b2\u03b4\u0003b1\u0000\u03b3\u03b2\u0001\u0000"+
"\u0000\u0000\u03b3\u03b4\u0001\u0000\u0000\u0000\u03b4\u03b6\u0001\u0000"+
"\u0000\u0000\u03b5\u03b7\u0003\u0092I\u0000\u03b6\u03b5\u0001\u0000\u0000"+
"\u0000\u03b6\u03b7\u0001\u0000\u0000\u0000\u03b7\u03b9\u0001\u0000\u0000"+
"\u0000\u03b8\u03ad\u0001\u0000\u0000\u0000\u03b8\u03af\u0001\u0000\u0000"+
"\u0000\u03b9\u0091\u0001\u0000\u0000\u0000\u03ba\u03bc\u00057\u0000\u0000"+
"\u03bb\u03bd\u0003b1\u0000\u03bc\u03bb\u0001\u0000\u0000\u0000\u03bc\u03bd"+
"\u0001\u0000\u0000\u0000\u03bd\u0093\u0001\u0000\u0000\u0000\u03be\u03c1"+
"\u0003v;\u0000\u03bf\u03c1\u0003t:\u0000\u03c0\u03be\u0001\u0000\u0000"+
"\u0000\u03c0\u03bf\u0001\u0000\u0000\u0000\u03c1\u03c9\u0001\u0000\u0000"+
"\u0000\u03c2\u03c5\u00056\u0000\u0000\u03c3\u03c6\u0003v;\u0000\u03c4"+
"\u03c6\u0003t:\u0000\u03c5\u03c3\u0001\u0000\u0000\u0000\u03c5\u03c4\u0001"+
"\u0000\u0000\u0000\u03c6\u03c8\u0001\u0000\u0000\u0000\u03c7\u03c2\u0001"+
"\u0000\u0000\u0000\u03c8\u03cb\u0001\u0000\u0000\u0000\u03c9\u03c7\u0001"+
"\u0000\u0000\u0000\u03c9\u03ca\u0001\u0000\u0000\u0000\u03ca\u03cd\u0001"+
"\u0000\u0000\u0000\u03cb\u03c9\u0001\u0000\u0000\u0000\u03cc\u03ce\u0005"+
"6\u0000\u0000\u03cd\u03cc\u0001\u0000\u0000\u0000\u03cd\u03ce\u0001\u0000"+
"\u0000\u0000\u03ce\u0095\u0001\u0000\u0000\u0000\u03cf\u03d4\u0003b1\u0000"+
"\u03d0\u03d1\u00056\u0000\u0000\u03d1\u03d3\u0003b1\u0000\u03d2\u03d0"+
"\u0001\u0000\u0000\u0000\u03d3\u03d6\u0001\u0000\u0000\u0000\u03d4\u03d2"+
"\u0001\u0000\u0000\u0000\u03d4\u03d5\u0001\u0000\u0000\u0000\u03d5\u03d8"+
"\u0001\u0000\u0000\u0000\u03d6\u03d4\u0001\u0000\u0000\u0000\u03d7\u03d9"+
"\u00056\u0000\u0000\u03d8\u03d7\u0001\u0000\u0000\u0000\u03d8\u03d9\u0001"+
"\u0000\u0000\u0000\u03d9\u0097\u0001\u0000\u0000\u0000\u03da\u03db\u0003"+
"b1\u0000\u03db\u03dc\u00057\u0000\u0000\u03dc\u03dd\u0003b1\u0000\u03dd"+
"\u03e1\u0001\u0000\u0000\u0000\u03de\u03df\u00059\u0000\u0000\u03df\u03e1"+
"\u0003v;\u0000\u03e0\u03da\u0001\u0000\u0000\u0000\u03e0\u03de\u0001\u0000"+
"\u0000\u0000\u03e1\u03f4\u0001\u0000\u0000\u0000\u03e2\u03f5\u0003\u00a2"+
"Q\u0000\u03e3\u03ea\u00056\u0000\u0000\u03e4\u03e5\u0003b1\u0000\u03e5"+
"\u03e6\u00057\u0000\u0000\u03e6\u03e7\u0003b1\u0000\u03e7\u03eb\u0001"+
"\u0000\u0000\u0000\u03e8\u03e9\u00059\u0000\u0000\u03e9\u03eb\u0003v;"+
"\u0000\u03ea\u03e4\u0001\u0000\u0000\u0000\u03ea\u03e8\u0001\u0000\u0000"+
"\u0000\u03eb\u03ed\u0001\u0000\u0000\u0000\u03ec\u03e3\u0001\u0000\u0000"+
"\u0000\u03ed\u03f0\u0001\u0000\u0000\u0000\u03ee\u03ec\u0001\u0000\u0000"+
"\u0000\u03ee\u03ef\u0001\u0000\u0000\u0000\u03ef\u03f2\u0001\u0000\u0000"+
"\u0000\u03f0\u03ee\u0001\u0000\u0000\u0000\u03f1\u03f3\u00056\u0000\u0000"+
"\u03f2\u03f1\u0001\u0000\u0000\u0000\u03f2\u03f3\u0001\u0000\u0000\u0000"+
"\u03f3\u03f5\u0001\u0000\u0000\u0000\u03f4\u03e2\u0001\u0000\u0000\u0000"+
"\u03f4\u03ee\u0001\u0000\u0000\u0000\u03f5\u040b\u0001\u0000\u0000\u0000"+
"\u03f6\u03f9\u0003b1\u0000\u03f7\u03f9\u0003t:\u0000\u03f8\u03f6\u0001"+
"\u0000\u0000\u0000\u03f8\u03f7\u0001\u0000\u0000\u0000\u03f9\u0408\u0001"+
"\u0000\u0000\u0000\u03fa\u0409\u0003\u00a2Q\u0000\u03fb\u03fe\u00056\u0000"+
"\u0000\u03fc\u03ff\u0003b1\u0000\u03fd\u03ff\u0003t:\u0000\u03fe\u03fc"+
"\u0001\u0000\u0000\u0000\u03fe\u03fd\u0001\u0000\u0000\u0000\u03ff\u0401"+
"\u0001\u0000\u0000\u0000\u0400\u03fb\u0001\u0000\u0000\u0000\u0401\u0404"+
"\u0001\u0000\u0000\u0000\u0402\u0400\u0001\u0000\u0000\u0000\u0402\u0403"+
"\u0001\u0000\u0000\u0000\u0403\u0406\u0001\u0000\u0000\u0000\u0404\u0402"+
"\u0001\u0000\u0000\u0000\u0405\u0407\u00056\u0000\u0000\u0406\u0405\u0001"+
"\u0000\u0000\u0000\u0406\u0407\u0001\u0000\u0000\u0000\u0407\u0409\u0001"+
"\u0000\u0000\u0000\u0408\u03fa\u0001\u0000\u0000\u0000\u0408\u0402\u0001"+
"\u0000\u0000\u0000\u0409\u040b\u0001\u0000\u0000\u0000\u040a\u03e0\u0001"+
"\u0000\u0000\u0000\u040a\u03f8\u0001\u0000\u0000\u0000\u040b\u0099\u0001"+
"\u0000\u0000\u0000\u040c\u040d\u0005\u001f\u0000\u0000\u040d\u0413\u0005"+
"(\u0000\u0000\u040e\u0410\u00054\u0000\u0000\u040f\u0411\u0003\u009cN"+
"\u0000\u0410\u040f\u0001\u0000\u0000\u0000\u0410\u0411\u0001\u0000\u0000"+
"\u0000\u0411\u0412\u0001\u0000\u0000\u0000\u0412\u0414\u00055\u0000\u0000"+
"\u0413\u040e\u0001\u0000\u0000\u0000\u0413\u0414\u0001\u0000\u0000\u0000"+
"\u0414\u0415\u0001\u0000\u0000\u0000\u0415\u0416\u00057\u0000\u0000\u0416"+
"\u0417\u0003`0\u0000\u0417\u009b\u0001\u0000\u0000\u0000\u0418\u041d\u0003"+
"\u009eO\u0000\u0419\u041a\u00056\u0000\u0000\u041a\u041c\u0003\u009eO"+
"\u0000\u041b\u0419\u0001\u0000\u0000\u0000\u041c\u041f\u0001\u0000\u0000"+
"\u0000\u041d\u041b\u0001\u0000\u0000\u0000\u041d\u041e\u0001\u0000\u0000"+
"\u0000\u041e\u0421\u0001\u0000\u0000\u0000\u041f\u041d\u0001\u0000\u0000"+
"\u0000\u0420\u0422\u00056\u0000\u0000\u0421\u0420\u0001\u0000\u0000\u0000"+
"\u0421\u0422\u0001\u0000\u0000\u0000\u0422\u009d\u0001\u0000\u0000\u0000"+
"\u0423\u0425\u0003b1\u0000\u0424\u0426\u0003\u00a2Q\u0000\u0425\u0424"+
"\u0001\u0000\u0000\u0000\u0425\u0426\u0001\u0000\u0000\u0000\u0426\u0430"+
"\u0001\u0000\u0000\u0000\u0427\u0428\u0003b1\u0000\u0428\u0429\u0005:"+
"\u0000\u0000\u0429\u042a\u0003b1\u0000\u042a\u0430\u0001\u0000\u0000\u0000"+
"\u042b\u042c\u00059\u0000\u0000\u042c\u0430\u0003b1\u0000\u042d\u042e"+
"\u00053\u0000\u0000\u042e\u0430\u0003b1\u0000\u042f\u0423\u0001\u0000"+
"\u0000\u0000\u042f\u0427\u0001\u0000\u0000\u0000\u042f\u042b\u0001\u0000"+
"\u0000\u0000\u042f\u042d\u0001\u0000\u0000\u0000\u0430\u009f\u0001\u0000"+
"\u0000\u0000\u0431\u0434\u0003\u00a2Q\u0000\u0432\u0434\u0003\u00a4R\u0000"+
"\u0433\u0431\u0001\u0000\u0000\u0000\u0433\u0432\u0001\u0000\u0000\u0000"+
"\u0434\u00a1\u0001\u0000\u0000\u0000\u0435\u0437\u0005%\u0000\u0000\u0436"+
"\u0435\u0001\u0000\u0000\u0000\u0436\u0437\u0001\u0000\u0000\u0000\u0437"+
"\u0438\u0001\u0000\u0000\u0000\u0438\u0439\u0005\u0011\u0000\u0000\u0439"+
"\u043a\u0003\u0094J\u0000\u043a\u043b\u0005\u0012\u0000\u0000\u043b\u043d"+
"\u0003j5\u0000\u043c\u043e\u0003\u00a0P\u0000\u043d\u043c\u0001\u0000"+
"\u0000\u0000\u043d\u043e\u0001\u0000\u0000\u0000\u043e\u00a3\u0001\u0000"+
"\u0000\u0000\u043f\u0440\u0005\r\u0000\u0000\u0440\u0442\u0003d2\u0000"+
"\u0441\u0443\u0003\u00a0P\u0000\u0442\u0441\u0001\u0000\u0000\u0000\u0442"+
"\u0443\u0001\u0000\u0000\u0000\u0443\u00a5\u0001\u0000\u0000\u0000\u0444"+
"\u0445\u0005(\u0000\u0000\u0445\u00a7\u0001\u0000\u0000\u0000\u0446\u0448"+
"\u0005 \u0000\u0000\u0447\u0449\u0003\u00aaU\u0000\u0448\u0447\u0001\u0000"+
"\u0000\u0000\u0448\u0449\u0001\u0000\u0000\u0000\u0449\u00a9\u0001\u0000"+
"\u0000\u0000\u044a\u044b\u0005\u0007\u0000\u0000\u044b\u044e\u0003b1\u0000"+
"\u044c\u044e\u0003\u0096K\u0000\u044d\u044a\u0001\u0000\u0000\u0000\u044d"+
"\u044c\u0001\u0000\u0000\u0000\u044e\u00ab\u0001\u0000\u0000\u0000\u00a6"+
"\u00b1\u00b5\u00b7\u00c0\u00c9\u00cc\u00d3\u00d9\u00e3\u00ea\u00f1\u00f7"+
"\u00fb\u0101\u0107\u010b\u0112\u0114\u0116\u011b\u011d\u011f\u0123\u0129"+
"\u012d\u0134\u0136\u0138\u013d\u013f\u0144\u0149\u014f\u0153\u0159\u015f"+
"\u0163\u016a\u016c\u016e\u0173\u0175\u0177\u017b\u0181\u0185\u018c\u018e"+
"\u0190\u0195\u0197\u019d\u01a4\u01a8\u01b4\u01bb\u01c0\u01c4\u01c7\u01cd"+
"\u01d1\u01d6\u01da\u01de\u01ec\u01f4\u01fc\u01fe\u0202\u020b\u0212\u0214"+
"\u021d\u0222\u0227\u022e\u0232\u0239\u0241\u024a\u0253\u025a\u0265\u026b"+
"\u0278\u027e\u0287\u0292\u029d\u02a2\u02a7\u02ac\u02b4\u02bd\u02c3\u02c5"+
"\u02cd\u02d1\u02d9\u02dc\u02e0\u02e4\u02eb\u02f5\u02fd\u0303\u030b\u031b"+
"\u0325\u032d\u0335\u033d\u0345\u034d\u0353\u0358\u035b\u0361\u0367\u036c"+
"\u0371\u0379\u037f\u0383\u0389\u038d\u0391\u0393\u0397\u03a0\u03a7\u03ab"+
"\u03af\u03b3\u03b6\u03b8\u03bc\u03c0\u03c5\u03c9\u03cd\u03d4\u03d8\u03e0"+
"\u03ea\u03ee\u03f2\u03f4\u03f8\u03fe\u0402\u0406\u0408\u040a\u0410\u0413"+
"\u041d\u0421\u0425\u042f\u0433\u0436\u043d\u0442\u0448\u044d";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
