ielnaczo.python3parser.1.0.4.source-code.Python3Parser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of python3parser Show documentation
Show all versions of python3parser Show documentation
A Java-based Python3-Parser.
// Generated from Python3.g4 by ANTLR 4.7.1
package io.github.danielnaczo.python3parser;
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"})
public class Python3Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", 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_funcdef = 4, RULE_parameters = 5, RULE_typedargslist = 6, RULE_tfpdef = 7,
RULE_normalOrDefaultTfpDef = 8, RULE_defaultTfpdef = 9, RULE_completeArgs = 10,
RULE_afterPositionalArgs = 11, RULE_positionalList = 12, RULE_kwlistArgs1 = 13,
RULE_justKeywordsArgs = 14, RULE_kwlistArgs2 = 15, RULE_kwOnlyListArgs = 16,
RULE_varargslist = 17, RULE_vfpdef = 18, RULE_varNormalOrDefaultTfpDef = 19,
RULE_varDefaultVfpdef = 20, RULE_varCompleteArgs = 21, RULE_varAfterPositionalArgs = 22,
RULE_varPositionalList = 23, RULE_varKwlistArgs1 = 24, RULE_varJustKeywordsArgs = 25,
RULE_varKwlistArgs2 = 26, RULE_varKwOnlyListArgs = 27, RULE_stmt = 28,
RULE_simple_stmt = 29, RULE_small_stmt = 30, RULE_expr_stmt = 31, RULE_expr_stmtIndividualAssign = 32,
RULE_expr_stmtNormalAssign = 33, RULE_expr_NormalAssignList = 34, RULE_annassign = 35,
RULE_testlist_star_expr = 36, RULE_testOrStar_expr = 37, RULE_testOrStarList_expr = 38,
RULE_augassign = 39, RULE_del_stmt = 40, RULE_pass_stmt = 41, RULE_flow_stmt = 42,
RULE_break_stmt = 43, RULE_continue_stmt = 44, RULE_return_stmt = 45,
RULE_yield_stmt = 46, RULE_raise_stmt = 47, RULE_import_stmt = 48, RULE_import_name = 49,
RULE_import_from = 50, RULE_import_as_name = 51, RULE_dotted_as_name = 52,
RULE_import_as_names = 53, RULE_dotted_as_names = 54, RULE_dotted_name = 55,
RULE_global_stmt = 56, RULE_nonlocal_stmt = 57, RULE_assert_stmt = 58,
RULE_compound_stmt = 59, RULE_async_stmt = 60, RULE_if_stmt = 61, RULE_while_stmt = 62,
RULE_for_stmt = 63, RULE_try_stmt = 64, RULE_with_stmt = 65, RULE_with_item = 66,
RULE_except_clause = 67, RULE_suite = 68, RULE_test = 69, RULE_test_nocond = 70,
RULE_lambdef = 71, RULE_lambdef_nocond = 72, RULE_or_test = 73, RULE_and_test = 74,
RULE_not_test = 75, RULE_comparison = 76, RULE_comp_op = 77, RULE_star_expr = 78,
RULE_expr = 79, RULE_xor_expr = 80, RULE_and_expr = 81, RULE_shift_expr = 82,
RULE_shift_op = 83, RULE_arith_expr = 84, RULE_arith_op = 85, RULE_term = 86,
RULE_term_op = 87, RULE_factor = 88, RULE_factor_op = 89, RULE_power = 90,
RULE_await = 91, RULE_atom_expr = 92, RULE_atom = 93, RULE_trailer = 94,
RULE_trailerCall = 95, RULE_trailerSubscript = 96, RULE_trailerName = 97,
RULE_tuple = 98, RULE_testlist_compTuple = 99, RULE_list = 100, RULE_testlist_compList = 101,
RULE_dictionaryOrSet = 102, RULE_dictorsetmaker = 103, RULE_dictFirst = 104,
RULE_dicts = 105, RULE_setFirst = 106, RULE_sets = 107, RULE_subscriptlist = 108,
RULE_subscript = 109, RULE_subscriptIndex = 110, RULE_subscriptSlice = 111,
RULE_slicelLower = 112, RULE_sliceUpper = 113, RULE_sliceStep = 114, RULE_exprlist = 115,
RULE_exprOrStarExpr = 116, RULE_testlist = 117, RULE_classdef = 118, RULE_arglist = 119,
RULE_argument = 120, RULE_argumentNormal = 121, RULE_argumentKeyword = 122,
RULE_argumentStar = 123, RULE_argumentDoubleStar = 124, RULE_comp_for = 125,
RULE_comp_if = 126, RULE_yield_expr = 127, RULE_yield_arg = 128;
public static final String[] ruleNames = {
"single_input", "file_input", "eval_input", "decorator", "funcdef", "parameters",
"typedargslist", "tfpdef", "normalOrDefaultTfpDef", "defaultTfpdef", "completeArgs",
"afterPositionalArgs", "positionalList", "kwlistArgs1", "justKeywordsArgs",
"kwlistArgs2", "kwOnlyListArgs", "varargslist", "vfpdef", "varNormalOrDefaultTfpDef",
"varDefaultVfpdef", "varCompleteArgs", "varAfterPositionalArgs", "varPositionalList",
"varKwlistArgs1", "varJustKeywordsArgs", "varKwlistArgs2", "varKwOnlyListArgs",
"stmt", "simple_stmt", "small_stmt", "expr_stmt", "expr_stmtIndividualAssign",
"expr_stmtNormalAssign", "expr_NormalAssignList", "annassign", "testlist_star_expr",
"testOrStar_expr", "testOrStarList_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", "shift_op", "arith_expr",
"arith_op", "term", "term_op", "factor", "factor_op", "power", "await",
"atom_expr", "atom", "trailer", "trailerCall", "trailerSubscript", "trailerName",
"tuple", "testlist_compTuple", "list", "testlist_compList", "dictionaryOrSet",
"dictorsetmaker", "dictFirst", "dicts", "setFirst", "sets", "subscriptlist",
"subscript", "subscriptIndex", "subscriptSlice", "slicelLower", "sliceUpper",
"sliceStep", "exprlist", "exprOrStarExpr", "testlist", "classdef", "arglist",
"argument", "argumentNormal", "argumentKeyword", "argumentStar", "argumentDoubleStar",
"comp_for", "comp_if", "yield_expr", "yield_arg"
};
private static final String[] _LITERAL_NAMES = {
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[] _SYMBOLIC_NAMES = {
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"
};
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);
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSingle_input(this);
else return visitor.visitChildren(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(263);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NEWLINE:
enterOuterAlt(_localctx, 1);
{
setState(258);
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(259);
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(260);
compound_stmt();
setState(261);
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;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitFile_input(this);
else return visitor.visitChildren(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(269);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << DEF) | (1L << RETURN) | (1L << RAISE) | (1L << FROM) | (1L << IMPORT) | (1L << GLOBAL) | (1L << NONLOCAL) | (1L << ASSERT) | (1L << IF) | (1L << WHILE) | (1L << FOR) | (1L << TRY) | (1L << WITH) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << CLASS) | (1L << YIELD) | (1L << DEL) | (1L << PASS) | (1L << CONTINUE) | (1L << BREAK) | (1L << ASYNC) | (1L << AWAIT) | (1L << NEWLINE) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)) | (1L << (AT - 66)))) != 0)) {
{
setState(267);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NEWLINE:
{
setState(265);
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(266);
stmt();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(271);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(272);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitEval_input(this);
else return visitor.visitChildren(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(274);
testlist();
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NEWLINE) {
{
{
setState(275);
match(NEWLINE);
}
}
setState(280);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(281);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecoratorContext extends ParserRuleContext {
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDecorator(this);
else return visitor.visitChildren(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(283);
match(AT);
setState(284);
dotted_name();
setState(290);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAREN) {
{
setState(285);
match(OPEN_PAREN);
setState(287);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(286);
arglist();
}
}
setState(289);
match(CLOSE_PAREN);
}
}
setState(292);
match(NEWLINE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncdefContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public ParametersContext parameters() {
return getRuleContext(ParametersContext.class,0);
}
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public List decorator() {
return getRuleContexts(DecoratorContext.class);
}
public DecoratorContext decorator(int i) {
return getRuleContext(DecoratorContext.class,i);
}
public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitFuncdef(this);
else return visitor.visitChildren(this);
}
}
public final FuncdefContext funcdef() throws RecognitionException {
FuncdefContext _localctx = new FuncdefContext(_ctx, getState());
enterRule(_localctx, 8, RULE_funcdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(297);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(294);
decorator();
}
}
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(301);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYNC) {
{
setState(300);
match(ASYNC);
}
}
setState(303);
match(DEF);
setState(304);
match(NAME);
setState(305);
parameters();
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ARROW) {
{
setState(306);
match(ARROW);
setState(307);
test();
}
}
setState(310);
match(COLON);
setState(311);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParametersContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitParameters(this);
else return visitor.visitChildren(this);
}
}
public final ParametersContext parameters() throws RecognitionException {
ParametersContext _localctx = new ParametersContext(_ctx, getState());
enterRule(_localctx, 10, RULE_parameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(313);
match(OPEN_PAREN);
setState(315);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) {
{
setState(314);
typedargslist();
}
}
setState(317);
match(CLOSE_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypedargslistContext extends ParserRuleContext {
public CompleteArgsContext completeArgs() {
return getRuleContext(CompleteArgsContext.class,0);
}
public JustKeywordsArgsContext justKeywordsArgs() {
return getRuleContext(JustKeywordsArgsContext.class,0);
}
public KwOnlyListArgsContext kwOnlyListArgs() {
return getRuleContext(KwOnlyListArgsContext.class,0);
}
public TypedargslistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typedargslist; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTypedargslist(this);
else return visitor.visitChildren(this);
}
}
public final TypedargslistContext typedargslist() throws RecognitionException {
TypedargslistContext _localctx = new TypedargslistContext(_ctx, getState());
enterRule(_localctx, 12, RULE_typedargslist);
try {
setState(322);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NAME:
enterOuterAlt(_localctx, 1);
{
setState(319);
completeArgs();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(320);
justKeywordsArgs();
}
break;
case POWER:
enterOuterAlt(_localctx, 3);
{
setState(321);
kwOnlyListArgs();
}
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 class TfpdefContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTfpdef(this);
else return visitor.visitChildren(this);
}
}
public final TfpdefContext tfpdef() throws RecognitionException {
TfpdefContext _localctx = new TfpdefContext(_ctx, getState());
enterRule(_localctx, 14, RULE_tfpdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(324);
match(NAME);
setState(327);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(325);
match(COLON);
setState(326);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalOrDefaultTfpDefContext extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public DefaultTfpdefContext defaultTfpdef() {
return getRuleContext(DefaultTfpdefContext.class,0);
}
public NormalOrDefaultTfpDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalOrDefaultTfpDef; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitNormalOrDefaultTfpDef(this);
else return visitor.visitChildren(this);
}
}
public final NormalOrDefaultTfpDefContext normalOrDefaultTfpDef() throws RecognitionException {
NormalOrDefaultTfpDefContext _localctx = new NormalOrDefaultTfpDefContext(_ctx, getState());
enterRule(_localctx, 16, RULE_normalOrDefaultTfpDef);
try {
setState(331);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(329);
tfpdef();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(330);
defaultTfpdef();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultTfpdefContext extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public DefaultTfpdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultTfpdef; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDefaultTfpdef(this);
else return visitor.visitChildren(this);
}
}
public final DefaultTfpdefContext defaultTfpdef() throws RecognitionException {
DefaultTfpdefContext _localctx = new DefaultTfpdefContext(_ctx, getState());
enterRule(_localctx, 18, RULE_defaultTfpdef);
try {
enterOuterAlt(_localctx, 1);
{
setState(333);
tfpdef();
setState(334);
match(ASSIGN);
setState(335);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CompleteArgsContext extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public DefaultTfpdefContext defaultTfpdef() {
return getRuleContext(DefaultTfpdefContext.class,0);
}
public List normalOrDefaultTfpDef() {
return getRuleContexts(NormalOrDefaultTfpDefContext.class);
}
public NormalOrDefaultTfpDefContext normalOrDefaultTfpDef(int i) {
return getRuleContext(NormalOrDefaultTfpDefContext.class,i);
}
public AfterPositionalArgsContext afterPositionalArgs() {
return getRuleContext(AfterPositionalArgsContext.class,0);
}
public CompleteArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_completeArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitCompleteArgs(this);
else return visitor.visitChildren(this);
}
}
public final CompleteArgsContext completeArgs() throws RecognitionException {
CompleteArgsContext _localctx = new CompleteArgsContext(_ctx, getState());
enterRule(_localctx, 20, RULE_completeArgs);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(337);
tfpdef();
}
break;
case 2:
{
setState(338);
defaultTfpdef();
}
break;
}
setState(345);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(341);
match(COMMA);
setState(342);
normalOrDefaultTfpDef();
}
}
}
setState(347);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(348);
afterPositionalArgs();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AfterPositionalArgsContext extends ParserRuleContext {
public PositionalListContext positionalList() {
return getRuleContext(PositionalListContext.class,0);
}
public KwlistArgs1Context kwlistArgs1() {
return getRuleContext(KwlistArgs1Context.class,0);
}
public List normalOrDefaultTfpDef() {
return getRuleContexts(NormalOrDefaultTfpDefContext.class);
}
public NormalOrDefaultTfpDefContext normalOrDefaultTfpDef(int i) {
return getRuleContext(NormalOrDefaultTfpDefContext.class,i);
}
public AfterPositionalArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_afterPositionalArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAfterPositionalArgs(this);
else return visitor.visitChildren(this);
}
}
public final AfterPositionalArgsContext afterPositionalArgs() throws RecognitionException {
AfterPositionalArgsContext _localctx = new AfterPositionalArgsContext(_ctx, getState());
enterRule(_localctx, 22, RULE_afterPositionalArgs);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(351);
match(COMMA);
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STAR) {
{
setState(352);
positionalList();
setState(357);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(353);
match(COMMA);
setState(354);
normalOrDefaultTfpDef();
}
}
}
setState(359);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
}
setState(360);
kwlistArgs1();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PositionalListContext extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public PositionalListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_positionalList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitPositionalList(this);
else return visitor.visitChildren(this);
}
}
public final PositionalListContext positionalList() throws RecognitionException {
PositionalListContext _localctx = new PositionalListContext(_ctx, getState());
enterRule(_localctx, 24, RULE_positionalList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(364);
match(STAR);
setState(366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(365);
tfpdef();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KwlistArgs1Context extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public KwlistArgs1Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_kwlistArgs1; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitKwlistArgs1(this);
else return visitor.visitChildren(this);
}
}
public final KwlistArgs1Context kwlistArgs1() throws RecognitionException {
KwlistArgs1Context _localctx = new KwlistArgs1Context(_ctx, getState());
enterRule(_localctx, 26, RULE_kwlistArgs1);
int _la;
try {
setState(383);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLOSE_PAREN:
case COMMA:
enterOuterAlt(_localctx, 1);
{
setState(376);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(368);
match(COMMA);
setState(374);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(369);
match(POWER);
setState(370);
tfpdef();
setState(372);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(371);
match(COMMA);
}
}
}
}
}
}
}
break;
case POWER:
enterOuterAlt(_localctx, 2);
{
setState(378);
match(POWER);
setState(379);
tfpdef();
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(380);
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;
}
public static class JustKeywordsArgsContext extends ParserRuleContext {
public PositionalListContext positionalList() {
return getRuleContext(PositionalListContext.class,0);
}
public List normalOrDefaultTfpDef() {
return getRuleContexts(NormalOrDefaultTfpDefContext.class);
}
public NormalOrDefaultTfpDefContext normalOrDefaultTfpDef(int i) {
return getRuleContext(NormalOrDefaultTfpDefContext.class,i);
}
public KwlistArgs2Context kwlistArgs2() {
return getRuleContext(KwlistArgs2Context.class,0);
}
public JustKeywordsArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_justKeywordsArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitJustKeywordsArgs(this);
else return visitor.visitChildren(this);
}
}
public final JustKeywordsArgsContext justKeywordsArgs() throws RecognitionException {
JustKeywordsArgsContext _localctx = new JustKeywordsArgsContext(_ctx, getState());
enterRule(_localctx, 28, RULE_justKeywordsArgs);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(385);
positionalList();
setState(390);
_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(386);
match(COMMA);
setState(387);
normalOrDefaultTfpDef();
}
}
}
setState(392);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
setState(394);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(393);
kwlistArgs2();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KwlistArgs2Context extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public KwlistArgs2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_kwlistArgs2; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitKwlistArgs2(this);
else return visitor.visitChildren(this);
}
}
public final KwlistArgs2Context kwlistArgs2() throws RecognitionException {
KwlistArgs2Context _localctx = new KwlistArgs2Context(_ctx, getState());
enterRule(_localctx, 30, RULE_kwlistArgs2);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(396);
match(COMMA);
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(397);
match(POWER);
setState(398);
tfpdef();
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(399);
match(COMMA);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KwOnlyListArgsContext extends ParserRuleContext {
public TfpdefContext tfpdef() {
return getRuleContext(TfpdefContext.class,0);
}
public KwOnlyListArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_kwOnlyListArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitKwOnlyListArgs(this);
else return visitor.visitChildren(this);
}
}
public final KwOnlyListArgsContext kwOnlyListArgs() throws RecognitionException {
KwOnlyListArgsContext _localctx = new KwOnlyListArgsContext(_ctx, getState());
enterRule(_localctx, 32, RULE_kwOnlyListArgs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(404);
match(POWER);
setState(405);
tfpdef();
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(406);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarargslistContext extends ParserRuleContext {
public VarCompleteArgsContext varCompleteArgs() {
return getRuleContext(VarCompleteArgsContext.class,0);
}
public VarJustKeywordsArgsContext varJustKeywordsArgs() {
return getRuleContext(VarJustKeywordsArgsContext.class,0);
}
public VarKwOnlyListArgsContext varKwOnlyListArgs() {
return getRuleContext(VarKwOnlyListArgsContext.class,0);
}
public VarargslistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varargslist; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarargslist(this);
else return visitor.visitChildren(this);
}
}
public final VarargslistContext varargslist() throws RecognitionException {
VarargslistContext _localctx = new VarargslistContext(_ctx, getState());
enterRule(_localctx, 34, RULE_varargslist);
try {
setState(412);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NAME:
enterOuterAlt(_localctx, 1);
{
setState(409);
varCompleteArgs();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(410);
varJustKeywordsArgs();
}
break;
case POWER:
enterOuterAlt(_localctx, 3);
{
setState(411);
varKwOnlyListArgs();
}
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 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVfpdef(this);
else return visitor.visitChildren(this);
}
}
public final VfpdefContext vfpdef() throws RecognitionException {
VfpdefContext _localctx = new VfpdefContext(_ctx, getState());
enterRule(_localctx, 36, RULE_vfpdef);
try {
enterOuterAlt(_localctx, 1);
{
setState(414);
match(NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarNormalOrDefaultTfpDefContext extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public VarDefaultVfpdefContext varDefaultVfpdef() {
return getRuleContext(VarDefaultVfpdefContext.class,0);
}
public VarNormalOrDefaultTfpDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varNormalOrDefaultTfpDef; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarNormalOrDefaultTfpDef(this);
else return visitor.visitChildren(this);
}
}
public final VarNormalOrDefaultTfpDefContext varNormalOrDefaultTfpDef() throws RecognitionException {
VarNormalOrDefaultTfpDefContext _localctx = new VarNormalOrDefaultTfpDefContext(_ctx, getState());
enterRule(_localctx, 38, RULE_varNormalOrDefaultTfpDef);
try {
setState(418);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(416);
vfpdef();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(417);
varDefaultVfpdef();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarDefaultVfpdefContext extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public VarDefaultVfpdefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varDefaultVfpdef; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarDefaultVfpdef(this);
else return visitor.visitChildren(this);
}
}
public final VarDefaultVfpdefContext varDefaultVfpdef() throws RecognitionException {
VarDefaultVfpdefContext _localctx = new VarDefaultVfpdefContext(_ctx, getState());
enterRule(_localctx, 40, RULE_varDefaultVfpdef);
try {
enterOuterAlt(_localctx, 1);
{
setState(420);
vfpdef();
setState(421);
match(ASSIGN);
setState(422);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarCompleteArgsContext extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public VarDefaultVfpdefContext varDefaultVfpdef() {
return getRuleContext(VarDefaultVfpdefContext.class,0);
}
public List varNormalOrDefaultTfpDef() {
return getRuleContexts(VarNormalOrDefaultTfpDefContext.class);
}
public VarNormalOrDefaultTfpDefContext varNormalOrDefaultTfpDef(int i) {
return getRuleContext(VarNormalOrDefaultTfpDefContext.class,i);
}
public VarAfterPositionalArgsContext varAfterPositionalArgs() {
return getRuleContext(VarAfterPositionalArgsContext.class,0);
}
public VarCompleteArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varCompleteArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarCompleteArgs(this);
else return visitor.visitChildren(this);
}
}
public final VarCompleteArgsContext varCompleteArgs() throws RecognitionException {
VarCompleteArgsContext _localctx = new VarCompleteArgsContext(_ctx, getState());
enterRule(_localctx, 42, RULE_varCompleteArgs);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(426);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(424);
vfpdef();
}
break;
case 2:
{
setState(425);
varDefaultVfpdef();
}
break;
}
setState(432);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(428);
match(COMMA);
setState(429);
varNormalOrDefaultTfpDef();
}
}
}
setState(434);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
}
setState(436);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(435);
varAfterPositionalArgs();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarAfterPositionalArgsContext extends ParserRuleContext {
public VarPositionalListContext varPositionalList() {
return getRuleContext(VarPositionalListContext.class,0);
}
public VarKwlistArgs1Context varKwlistArgs1() {
return getRuleContext(VarKwlistArgs1Context.class,0);
}
public List varNormalOrDefaultTfpDef() {
return getRuleContexts(VarNormalOrDefaultTfpDefContext.class);
}
public VarNormalOrDefaultTfpDefContext varNormalOrDefaultTfpDef(int i) {
return getRuleContext(VarNormalOrDefaultTfpDefContext.class,i);
}
public VarAfterPositionalArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varAfterPositionalArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarAfterPositionalArgs(this);
else return visitor.visitChildren(this);
}
}
public final VarAfterPositionalArgsContext varAfterPositionalArgs() throws RecognitionException {
VarAfterPositionalArgsContext _localctx = new VarAfterPositionalArgsContext(_ctx, getState());
enterRule(_localctx, 44, RULE_varAfterPositionalArgs);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(438);
match(COMMA);
setState(449);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STAR) {
{
setState(439);
varPositionalList();
setState(444);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(440);
match(COMMA);
setState(441);
varNormalOrDefaultTfpDef();
}
}
}
setState(446);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
}
setState(447);
varKwlistArgs1();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarPositionalListContext extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public VarPositionalListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varPositionalList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarPositionalList(this);
else return visitor.visitChildren(this);
}
}
public final VarPositionalListContext varPositionalList() throws RecognitionException {
VarPositionalListContext _localctx = new VarPositionalListContext(_ctx, getState());
enterRule(_localctx, 46, RULE_varPositionalList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(451);
match(STAR);
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NAME) {
{
setState(452);
vfpdef();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarKwlistArgs1Context extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public VarKwlistArgs1Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varKwlistArgs1; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarKwlistArgs1(this);
else return visitor.visitChildren(this);
}
}
public final VarKwlistArgs1Context varKwlistArgs1() throws RecognitionException {
VarKwlistArgs1Context _localctx = new VarKwlistArgs1Context(_ctx, getState());
enterRule(_localctx, 48, RULE_varKwlistArgs1);
int _la;
try {
setState(470);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COMMA:
case COLON:
enterOuterAlt(_localctx, 1);
{
setState(463);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(455);
match(COMMA);
setState(461);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(456);
match(POWER);
setState(457);
vfpdef();
setState(459);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(458);
match(COMMA);
}
}
}
}
}
}
}
break;
case POWER:
enterOuterAlt(_localctx, 2);
{
setState(465);
match(POWER);
setState(466);
vfpdef();
setState(468);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(467);
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;
}
public static class VarJustKeywordsArgsContext extends ParserRuleContext {
public VarPositionalListContext varPositionalList() {
return getRuleContext(VarPositionalListContext.class,0);
}
public List varNormalOrDefaultTfpDef() {
return getRuleContexts(VarNormalOrDefaultTfpDefContext.class);
}
public VarNormalOrDefaultTfpDefContext varNormalOrDefaultTfpDef(int i) {
return getRuleContext(VarNormalOrDefaultTfpDefContext.class,i);
}
public VarKwlistArgs2Context varKwlistArgs2() {
return getRuleContext(VarKwlistArgs2Context.class,0);
}
public VarJustKeywordsArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varJustKeywordsArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarJustKeywordsArgs(this);
else return visitor.visitChildren(this);
}
}
public final VarJustKeywordsArgsContext varJustKeywordsArgs() throws RecognitionException {
VarJustKeywordsArgsContext _localctx = new VarJustKeywordsArgsContext(_ctx, getState());
enterRule(_localctx, 50, RULE_varJustKeywordsArgs);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(472);
varPositionalList();
setState(477);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(473);
match(COMMA);
setState(474);
varNormalOrDefaultTfpDef();
}
}
}
setState(479);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
}
setState(481);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(480);
varKwlistArgs2();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarKwlistArgs2Context extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public VarKwlistArgs2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varKwlistArgs2; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarKwlistArgs2(this);
else return visitor.visitChildren(this);
}
}
public final VarKwlistArgs2Context varKwlistArgs2() throws RecognitionException {
VarKwlistArgs2Context _localctx = new VarKwlistArgs2Context(_ctx, getState());
enterRule(_localctx, 52, RULE_varKwlistArgs2);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(483);
match(COMMA);
setState(489);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POWER) {
{
setState(484);
match(POWER);
setState(485);
vfpdef();
setState(487);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(486);
match(COMMA);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarKwOnlyListArgsContext extends ParserRuleContext {
public VfpdefContext vfpdef() {
return getRuleContext(VfpdefContext.class,0);
}
public VarKwOnlyListArgsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varKwOnlyListArgs; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitVarKwOnlyListArgs(this);
else return visitor.visitChildren(this);
}
}
public final VarKwOnlyListArgsContext varKwOnlyListArgs() throws RecognitionException {
VarKwOnlyListArgsContext _localctx = new VarKwOnlyListArgsContext(_ctx, getState());
enterRule(_localctx, 54, RULE_varKwOnlyListArgs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(491);
match(POWER);
setState(492);
vfpdef();
setState(494);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(493);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitStmt(this);
else return visitor.visitChildren(this);
}
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 56, RULE_stmt);
try {
setState(498);
_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(496);
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(497);
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;
}
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 Simple_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSimple_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Simple_stmtContext simple_stmt() throws RecognitionException {
Simple_stmtContext _localctx = new Simple_stmtContext(_ctx, getState());
enterRule(_localctx, 58, RULE_simple_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(500);
small_stmt();
setState(505);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,48,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(501);
match(SEMI_COLON);
setState(502);
small_stmt();
}
}
}
setState(507);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,48,_ctx);
}
setState(509);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI_COLON) {
{
setState(508);
match(SEMI_COLON);
}
}
setState(511);
match(NEWLINE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSmall_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Small_stmtContext small_stmt() throws RecognitionException {
Small_stmtContext _localctx = new Small_stmtContext(_ctx, getState());
enterRule(_localctx, 60, RULE_small_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(521);
_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(513);
expr_stmt();
}
break;
case DEL:
{
setState(514);
del_stmt();
}
break;
case PASS:
{
setState(515);
pass_stmt();
}
break;
case RETURN:
case RAISE:
case YIELD:
case CONTINUE:
case BREAK:
{
setState(516);
flow_stmt();
}
break;
case FROM:
case IMPORT:
{
setState(517);
import_stmt();
}
break;
case GLOBAL:
{
setState(518);
global_stmt();
}
break;
case NONLOCAL:
{
setState(519);
nonlocal_stmt();
}
break;
case ASSERT:
{
setState(520);
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;
}
public static class Expr_stmtContext extends ParserRuleContext {
public Testlist_star_exprContext testlist_star_expr() {
return getRuleContext(Testlist_star_exprContext.class,0);
}
public Expr_stmtIndividualAssignContext expr_stmtIndividualAssign() {
return getRuleContext(Expr_stmtIndividualAssignContext.class,0);
}
public Expr_stmtNormalAssignContext expr_stmtNormalAssign() {
return getRuleContext(Expr_stmtNormalAssignContext.class,0);
}
public Expr_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExpr_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Expr_stmtContext expr_stmt() throws RecognitionException {
Expr_stmtContext _localctx = new Expr_stmtContext(_ctx, getState());
enterRule(_localctx, 62, RULE_expr_stmt);
try {
setState(526);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(523);
testlist_star_expr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(524);
expr_stmtIndividualAssign();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(525);
expr_stmtNormalAssign();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Expr_stmtIndividualAssignContext extends ParserRuleContext {
public Testlist_star_exprContext testlist_star_expr() {
return getRuleContext(Testlist_star_exprContext.class,0);
}
public AnnassignContext annassign() {
return getRuleContext(AnnassignContext.class,0);
}
public AugassignContext augassign() {
return getRuleContext(AugassignContext.class,0);
}
public Yield_exprContext yield_expr() {
return getRuleContext(Yield_exprContext.class,0);
}
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public Expr_stmtIndividualAssignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_stmtIndividualAssign; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExpr_stmtIndividualAssign(this);
else return visitor.visitChildren(this);
}
}
public final Expr_stmtIndividualAssignContext expr_stmtIndividualAssign() throws RecognitionException {
Expr_stmtIndividualAssignContext _localctx = new Expr_stmtIndividualAssignContext(_ctx, getState());
enterRule(_localctx, 64, RULE_expr_stmtIndividualAssign);
try {
enterOuterAlt(_localctx, 1);
{
setState(528);
testlist_star_expr();
setState(535);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
{
setState(529);
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(530);
augassign();
setState(533);
_errHandler.sync(this);
switch (_input.LA(1)) {
case YIELD:
{
setState(531);
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(532);
testlist();
}
break;
default:
throw new NoViableAltException(this);
}
}
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 class Expr_stmtNormalAssignContext extends ParserRuleContext {
public Testlist_star_exprContext testlist_star_expr() {
return getRuleContext(Testlist_star_exprContext.class,0);
}
public List expr_NormalAssignList() {
return getRuleContexts(Expr_NormalAssignListContext.class);
}
public Expr_NormalAssignListContext expr_NormalAssignList(int i) {
return getRuleContext(Expr_NormalAssignListContext.class,i);
}
public Expr_stmtNormalAssignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_stmtNormalAssign; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExpr_stmtNormalAssign(this);
else return visitor.visitChildren(this);
}
}
public final Expr_stmtNormalAssignContext expr_stmtNormalAssign() throws RecognitionException {
Expr_stmtNormalAssignContext _localctx = new Expr_stmtNormalAssignContext(_ctx, getState());
enterRule(_localctx, 66, RULE_expr_stmtNormalAssign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(537);
testlist_star_expr();
setState(538);
match(ASSIGN);
setState(539);
expr_NormalAssignList();
setState(544);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ASSIGN) {
{
{
setState(540);
match(ASSIGN);
setState(541);
expr_NormalAssignList();
}
}
setState(546);
_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;
}
public static class Expr_NormalAssignListContext extends ParserRuleContext {
public Yield_exprContext yield_expr() {
return getRuleContext(Yield_exprContext.class,0);
}
public Testlist_star_exprContext testlist_star_expr() {
return getRuleContext(Testlist_star_exprContext.class,0);
}
public Expr_NormalAssignListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_NormalAssignList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExpr_NormalAssignList(this);
else return visitor.visitChildren(this);
}
}
public final Expr_NormalAssignListContext expr_NormalAssignList() throws RecognitionException {
Expr_NormalAssignListContext _localctx = new Expr_NormalAssignListContext(_ctx, getState());
enterRule(_localctx, 68, RULE_expr_NormalAssignList);
try {
setState(549);
_errHandler.sync(this);
switch (_input.LA(1)) {
case YIELD:
enterOuterAlt(_localctx, 1);
{
setState(547);
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:
enterOuterAlt(_localctx, 2);
{
setState(548);
testlist_star_expr();
}
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 class AnnassignContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public AnnassignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annassign; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAnnassign(this);
else return visitor.visitChildren(this);
}
}
public final AnnassignContext annassign() throws RecognitionException {
AnnassignContext _localctx = new AnnassignContext(_ctx, getState());
enterRule(_localctx, 70, RULE_annassign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(551);
match(COLON);
setState(552);
test();
setState(555);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(553);
match(ASSIGN);
setState(554);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Testlist_star_exprContext extends ParserRuleContext {
public TestOrStar_exprContext testOrStar_expr() {
return getRuleContext(TestOrStar_exprContext.class,0);
}
public List testOrStarList_expr() {
return getRuleContexts(TestOrStarList_exprContext.class);
}
public TestOrStarList_exprContext testOrStarList_expr(int i) {
return getRuleContext(TestOrStarList_exprContext.class,i);
}
public Testlist_star_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist_star_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTestlist_star_expr(this);
else return visitor.visitChildren(this);
}
}
public final Testlist_star_exprContext testlist_star_expr() throws RecognitionException {
Testlist_star_exprContext _localctx = new Testlist_star_exprContext(_ctx, getState());
enterRule(_localctx, 72, RULE_testlist_star_expr);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(557);
testOrStar_expr();
setState(562);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,57,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(558);
match(COMMA);
setState(559);
testOrStarList_expr();
}
}
}
setState(564);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,57,_ctx);
}
setState(566);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(565);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TestOrStar_exprContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public Star_exprContext star_expr() {
return getRuleContext(Star_exprContext.class,0);
}
public TestOrStar_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testOrStar_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTestOrStar_expr(this);
else return visitor.visitChildren(this);
}
}
public final TestOrStar_exprContext testOrStar_expr() throws RecognitionException {
TestOrStar_exprContext _localctx = new TestOrStar_exprContext(_ctx, getState());
enterRule(_localctx, 74, RULE_testOrStar_expr);
try {
setState(570);
_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:
enterOuterAlt(_localctx, 1);
{
setState(568);
test();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(569);
star_expr();
}
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 class TestOrStarList_exprContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public Star_exprContext star_expr() {
return getRuleContext(Star_exprContext.class,0);
}
public TestOrStarList_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testOrStarList_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTestOrStarList_expr(this);
else return visitor.visitChildren(this);
}
}
public final TestOrStarList_exprContext testOrStarList_expr() throws RecognitionException {
TestOrStarList_exprContext _localctx = new TestOrStarList_exprContext(_ctx, getState());
enterRule(_localctx, 76, RULE_testOrStarList_expr);
try {
setState(574);
_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:
enterOuterAlt(_localctx, 1);
{
setState(572);
test();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(573);
star_expr();
}
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 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAugassign(this);
else return visitor.visitChildren(this);
}
}
public final AugassignContext augassign() throws RecognitionException {
AugassignContext _localctx = new AugassignContext(_ctx, getState());
enterRule(_localctx, 78, RULE_augassign);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(576);
_la = _input.LA(1);
if ( !(((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (ADD_ASSIGN - 83)) | (1L << (SUB_ASSIGN - 83)) | (1L << (MULT_ASSIGN - 83)) | (1L << (AT_ASSIGN - 83)) | (1L << (DIV_ASSIGN - 83)) | (1L << (MOD_ASSIGN - 83)) | (1L << (AND_ASSIGN - 83)) | (1L << (OR_ASSIGN - 83)) | (1L << (XOR_ASSIGN - 83)) | (1L << (LEFT_SHIFT_ASSIGN - 83)) | (1L << (RIGHT_SHIFT_ASSIGN - 83)) | (1L << (POWER_ASSIGN - 83)) | (1L << (IDIV_ASSIGN - 83)))) != 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;
}
public static class Del_stmtContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDel_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Del_stmtContext del_stmt() throws RecognitionException {
Del_stmtContext _localctx = new Del_stmtContext(_ctx, getState());
enterRule(_localctx, 80, RULE_del_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(578);
match(DEL);
setState(579);
exprlist();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pass_stmtContext extends ParserRuleContext {
public Pass_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pass_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitPass_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Pass_stmtContext pass_stmt() throws RecognitionException {
Pass_stmtContext _localctx = new Pass_stmtContext(_ctx, getState());
enterRule(_localctx, 82, RULE_pass_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(581);
match(PASS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitFlow_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Flow_stmtContext flow_stmt() throws RecognitionException {
Flow_stmtContext _localctx = new Flow_stmtContext(_ctx, getState());
enterRule(_localctx, 84, RULE_flow_stmt);
try {
setState(588);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BREAK:
enterOuterAlt(_localctx, 1);
{
setState(583);
break_stmt();
}
break;
case CONTINUE:
enterOuterAlt(_localctx, 2);
{
setState(584);
continue_stmt();
}
break;
case RETURN:
enterOuterAlt(_localctx, 3);
{
setState(585);
return_stmt();
}
break;
case RAISE:
enterOuterAlt(_localctx, 4);
{
setState(586);
raise_stmt();
}
break;
case YIELD:
enterOuterAlt(_localctx, 5);
{
setState(587);
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;
}
public static class Break_stmtContext extends ParserRuleContext {
public Break_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_break_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitBreak_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Break_stmtContext break_stmt() throws RecognitionException {
Break_stmtContext _localctx = new Break_stmtContext(_ctx, getState());
enterRule(_localctx, 86, RULE_break_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(590);
match(BREAK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Continue_stmtContext extends ParserRuleContext {
public Continue_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continue_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitContinue_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Continue_stmtContext continue_stmt() throws RecognitionException {
Continue_stmtContext _localctx = new Continue_stmtContext(_ctx, getState());
enterRule(_localctx, 88, RULE_continue_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(592);
match(CONTINUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Return_stmtContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitReturn_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Return_stmtContext return_stmt() throws RecognitionException {
Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState());
enterRule(_localctx, 90, RULE_return_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(594);
match(RETURN);
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(595);
testlist();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitYield_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Yield_stmtContext yield_stmt() throws RecognitionException {
Yield_stmtContext _localctx = new Yield_stmtContext(_ctx, getState());
enterRule(_localctx, 92, RULE_yield_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(598);
yield_expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Raise_stmtContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public Raise_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_raise_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitRaise_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Raise_stmtContext raise_stmt() throws RecognitionException {
Raise_stmtContext _localctx = new Raise_stmtContext(_ctx, getState());
enterRule(_localctx, 94, RULE_raise_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(600);
match(RAISE);
setState(606);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(601);
test();
setState(604);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FROM) {
{
setState(602);
match(FROM);
setState(603);
test();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitImport_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Import_stmtContext import_stmt() throws RecognitionException {
Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState());
enterRule(_localctx, 96, RULE_import_stmt);
try {
setState(610);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IMPORT:
enterOuterAlt(_localctx, 1);
{
setState(608);
import_name();
}
break;
case FROM:
enterOuterAlt(_localctx, 2);
{
setState(609);
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;
}
public static class Import_nameContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitImport_name(this);
else return visitor.visitChildren(this);
}
}
public final Import_nameContext import_name() throws RecognitionException {
Import_nameContext _localctx = new Import_nameContext(_ctx, getState());
enterRule(_localctx, 98, RULE_import_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(612);
match(IMPORT);
setState(613);
dotted_as_names();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Import_fromContext extends ParserRuleContext {
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,0);
}
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public Import_as_namesContext import_as_names() {
return getRuleContext(Import_as_namesContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitImport_from(this);
else return visitor.visitChildren(this);
}
}
public final Import_fromContext import_from() throws RecognitionException {
Import_fromContext _localctx = new Import_fromContext(_ctx, getState());
enterRule(_localctx, 100, RULE_import_from);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(615);
match(FROM);
setState(628);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
case 1:
{
setState(619);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==ELLIPSIS) {
{
{
setState(616);
_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(621);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(622);
dotted_name();
}
break;
case 2:
{
setState(624);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(623);
_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(626);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==DOT || _la==ELLIPSIS );
}
break;
}
setState(630);
match(IMPORT);
setState(637);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(631);
match(STAR);
}
break;
case OPEN_PAREN:
{
setState(632);
match(OPEN_PAREN);
setState(633);
import_as_names();
setState(634);
match(CLOSE_PAREN);
}
break;
case NAME:
{
setState(636);
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;
}
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 Import_as_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_as_name; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitImport_as_name(this);
else return visitor.visitChildren(this);
}
}
public final Import_as_nameContext import_as_name() throws RecognitionException {
Import_as_nameContext _localctx = new Import_as_nameContext(_ctx, getState());
enterRule(_localctx, 102, RULE_import_as_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(639);
match(NAME);
setState(642);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(640);
match(AS);
setState(641);
match(NAME);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Dotted_as_nameContext extends ParserRuleContext {
public Dotted_nameContext dotted_name() {
return getRuleContext(Dotted_nameContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDotted_as_name(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_as_nameContext dotted_as_name() throws RecognitionException {
Dotted_as_nameContext _localctx = new Dotted_as_nameContext(_ctx, getState());
enterRule(_localctx, 104, RULE_dotted_as_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(644);
dotted_name();
setState(647);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(645);
match(AS);
setState(646);
match(NAME);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 Import_as_namesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_import_as_names; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitImport_as_names(this);
else return visitor.visitChildren(this);
}
}
public final Import_as_namesContext import_as_names() throws RecognitionException {
Import_as_namesContext _localctx = new Import_as_namesContext(_ctx, getState());
enterRule(_localctx, 106, RULE_import_as_names);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(649);
import_as_name();
setState(654);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(650);
match(COMMA);
setState(651);
import_as_name();
}
}
}
setState(656);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,72,_ctx);
}
setState(658);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(657);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 Dotted_as_namesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_as_names; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDotted_as_names(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_as_namesContext dotted_as_names() throws RecognitionException {
Dotted_as_namesContext _localctx = new Dotted_as_namesContext(_ctx, getState());
enterRule(_localctx, 108, RULE_dotted_as_names);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(660);
dotted_as_name();
setState(665);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(661);
match(COMMA);
setState(662);
dotted_as_name();
}
}
setState(667);
_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;
}
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 Dotted_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dotted_name; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDotted_name(this);
else return visitor.visitChildren(this);
}
}
public final Dotted_nameContext dotted_name() throws RecognitionException {
Dotted_nameContext _localctx = new Dotted_nameContext(_ctx, getState());
enterRule(_localctx, 110, RULE_dotted_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(668);
match(NAME);
setState(673);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(669);
match(DOT);
setState(670);
match(NAME);
}
}
setState(675);
_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;
}
public static class Global_stmtContext extends ParserRuleContext {
public List NAME() { return getTokens(Python3Parser.NAME); }
public TerminalNode NAME(int i) {
return getToken(Python3Parser.NAME, i);
}
public Global_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_global_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitGlobal_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Global_stmtContext global_stmt() throws RecognitionException {
Global_stmtContext _localctx = new Global_stmtContext(_ctx, getState());
enterRule(_localctx, 112, RULE_global_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(676);
match(GLOBAL);
setState(677);
match(NAME);
setState(682);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(678);
match(COMMA);
setState(679);
match(NAME);
}
}
setState(684);
_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;
}
public static class Nonlocal_stmtContext extends ParserRuleContext {
public List NAME() { return getTokens(Python3Parser.NAME); }
public TerminalNode NAME(int i) {
return getToken(Python3Parser.NAME, i);
}
public Nonlocal_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonlocal_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitNonlocal_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Nonlocal_stmtContext nonlocal_stmt() throws RecognitionException {
Nonlocal_stmtContext _localctx = new Nonlocal_stmtContext(_ctx, getState());
enterRule(_localctx, 114, RULE_nonlocal_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(685);
match(NONLOCAL);
setState(686);
match(NAME);
setState(691);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(687);
match(COMMA);
setState(688);
match(NAME);
}
}
setState(693);
_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;
}
public static class Assert_stmtContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public Assert_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assert_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAssert_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Assert_stmtContext assert_stmt() throws RecognitionException {
Assert_stmtContext _localctx = new Assert_stmtContext(_ctx, getState());
enterRule(_localctx, 116, RULE_assert_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(694);
match(ASSERT);
setState(695);
test();
setState(698);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(696);
match(COMMA);
setState(697);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitCompound_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Compound_stmtContext compound_stmt() throws RecognitionException {
Compound_stmtContext _localctx = new Compound_stmtContext(_ctx, getState());
enterRule(_localctx, 118, RULE_compound_stmt);
try {
setState(708);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(700);
if_stmt();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(701);
while_stmt();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(702);
for_stmt();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(703);
try_stmt();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(704);
with_stmt();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(705);
funcdef();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(706);
classdef();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(707);
async_stmt();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAsync_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Async_stmtContext async_stmt() throws RecognitionException {
Async_stmtContext _localctx = new Async_stmtContext(_ctx, getState());
enterRule(_localctx, 120, RULE_async_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(710);
match(ASYNC);
setState(714);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DEF:
case ASYNC:
case AT:
{
setState(711);
funcdef();
}
break;
case WITH:
{
setState(712);
with_stmt();
}
break;
case FOR:
{
setState(713);
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;
}
public static class If_stmtContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public If_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_if_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitIf_stmt(this);
else return visitor.visitChildren(this);
}
}
public final If_stmtContext if_stmt() throws RecognitionException {
If_stmtContext _localctx = new If_stmtContext(_ctx, getState());
enterRule(_localctx, 122, RULE_if_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(716);
match(IF);
setState(717);
test();
setState(718);
match(COLON);
setState(719);
suite();
setState(727);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ELIF) {
{
{
setState(720);
match(ELIF);
setState(721);
test();
setState(722);
match(COLON);
setState(723);
suite();
}
}
setState(729);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(733);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(730);
match(ELSE);
setState(731);
match(COLON);
setState(732);
suite();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class While_stmtContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public While_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_while_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitWhile_stmt(this);
else return visitor.visitChildren(this);
}
}
public final While_stmtContext while_stmt() throws RecognitionException {
While_stmtContext _localctx = new While_stmtContext(_ctx, getState());
enterRule(_localctx, 124, RULE_while_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(735);
match(WHILE);
setState(736);
test();
setState(737);
match(COLON);
setState(738);
suite();
setState(742);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(739);
match(ELSE);
setState(740);
match(COLON);
setState(741);
suite();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class For_stmtContext extends ParserRuleContext {
public ExprlistContext exprlist() {
return getRuleContext(ExprlistContext.class,0);
}
public TestlistContext testlist() {
return getRuleContext(TestlistContext.class,0);
}
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
public For_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_for_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitFor_stmt(this);
else return visitor.visitChildren(this);
}
}
public final For_stmtContext for_stmt() throws RecognitionException {
For_stmtContext _localctx = new For_stmtContext(_ctx, getState());
enterRule(_localctx, 126, RULE_for_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(744);
match(FOR);
setState(745);
exprlist();
setState(746);
match(IN);
setState(747);
testlist();
setState(748);
match(COLON);
setState(749);
suite();
setState(753);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(750);
match(ELSE);
setState(751);
match(COLON);
setState(752);
suite();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Try_stmtContext extends ParserRuleContext {
public List suite() {
return getRuleContexts(SuiteContext.class);
}
public SuiteContext suite(int i) {
return getRuleContext(SuiteContext.class,i);
}
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 TerminalNode FINALLY() { return getToken(Python3Parser.FINALLY, 0); }
public Try_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_try_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTry_stmt(this);
else return visitor.visitChildren(this);
}
}
public final Try_stmtContext try_stmt() throws RecognitionException {
Try_stmtContext _localctx = new Try_stmtContext(_ctx, getState());
enterRule(_localctx, 128, RULE_try_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(755);
match(TRY);
setState(756);
match(COLON);
setState(757);
suite();
setState(779);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EXCEPT:
{
setState(762);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(758);
except_clause();
setState(759);
match(COLON);
setState(760);
suite();
}
}
setState(764);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==EXCEPT );
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(766);
match(ELSE);
setState(767);
match(COLON);
setState(768);
suite();
}
}
setState(774);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(771);
match(FINALLY);
setState(772);
match(COLON);
setState(773);
suite();
}
}
}
break;
case FINALLY:
{
setState(776);
match(FINALLY);
setState(777);
match(COLON);
setState(778);
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;
}
public static class With_stmtContext extends ParserRuleContext {
public List with_item() {
return getRuleContexts(With_itemContext.class);
}
public With_itemContext with_item(int i) {
return getRuleContext(With_itemContext.class,i);
}
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public With_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with_stmt; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitWith_stmt(this);
else return visitor.visitChildren(this);
}
}
public final With_stmtContext with_stmt() throws RecognitionException {
With_stmtContext _localctx = new With_stmtContext(_ctx, getState());
enterRule(_localctx, 130, RULE_with_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(781);
match(WITH);
setState(782);
with_item();
setState(787);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(783);
match(COMMA);
setState(784);
with_item();
}
}
setState(789);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(790);
match(COLON);
setState(791);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class With_itemContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitWith_item(this);
else return visitor.visitChildren(this);
}
}
public final With_itemContext with_item() throws RecognitionException {
With_itemContext _localctx = new With_itemContext(_ctx, getState());
enterRule(_localctx, 132, RULE_with_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(793);
test();
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(794);
match(AS);
setState(795);
expr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Except_clauseContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExcept_clause(this);
else return visitor.visitChildren(this);
}
}
public final Except_clauseContext except_clause() throws RecognitionException {
Except_clauseContext _localctx = new Except_clauseContext(_ctx, getState());
enterRule(_localctx, 134, RULE_except_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(798);
match(EXCEPT);
setState(804);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(799);
test();
setState(802);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(800);
match(AS);
setState(801);
match(NAME);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSuite(this);
else return visitor.visitChildren(this);
}
}
public final SuiteContext suite() throws RecognitionException {
SuiteContext _localctx = new SuiteContext(_ctx, getState());
enterRule(_localctx, 136, RULE_suite);
int _la;
try {
setState(816);
_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(806);
simple_stmt();
}
break;
case NEWLINE:
enterOuterAlt(_localctx, 2);
{
setState(807);
match(NEWLINE);
setState(808);
match(INDENT);
setState(810);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(809);
stmt();
}
}
setState(812);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << DEF) | (1L << RETURN) | (1L << RAISE) | (1L << FROM) | (1L << IMPORT) | (1L << GLOBAL) | (1L << NONLOCAL) | (1L << ASSERT) | (1L << IF) | (1L << WHILE) | (1L << FOR) | (1L << TRY) | (1L << WITH) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << CLASS) | (1L << YIELD) | (1L << DEL) | (1L << PASS) | (1L << CONTINUE) | (1L << BREAK) | (1L << ASYNC) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)) | (1L << (AT - 66)))) != 0) );
setState(814);
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;
}
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 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTest(this);
else return visitor.visitChildren(this);
}
}
public final TestContext test() throws RecognitionException {
TestContext _localctx = new TestContext(_ctx, getState());
enterRule(_localctx, 138, RULE_test);
int _la;
try {
setState(827);
_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(818);
or_test();
setState(824);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IF) {
{
setState(819);
match(IF);
setState(820);
or_test();
setState(821);
match(ELSE);
setState(822);
test();
}
}
}
break;
case LAMBDA:
enterOuterAlt(_localctx, 2);
{
setState(826);
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;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTest_nocond(this);
else return visitor.visitChildren(this);
}
}
public final Test_nocondContext test_nocond() throws RecognitionException {
Test_nocondContext _localctx = new Test_nocondContext(_ctx, getState());
enterRule(_localctx, 140, RULE_test_nocond);
try {
setState(831);
_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(829);
or_test();
}
break;
case LAMBDA:
enterOuterAlt(_localctx, 2);
{
setState(830);
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;
}
public static class LambdefContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitLambdef(this);
else return visitor.visitChildren(this);
}
}
public final LambdefContext lambdef() throws RecognitionException {
LambdefContext _localctx = new LambdefContext(_ctx, getState());
enterRule(_localctx, 142, RULE_lambdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(833);
match(LAMBDA);
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) {
{
setState(834);
varargslist();
}
}
setState(837);
match(COLON);
setState(838);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Lambdef_nocondContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitLambdef_nocond(this);
else return visitor.visitChildren(this);
}
}
public final Lambdef_nocondContext lambdef_nocond() throws RecognitionException {
Lambdef_nocondContext _localctx = new Lambdef_nocondContext(_ctx, getState());
enterRule(_localctx, 144, RULE_lambdef_nocond);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(840);
match(LAMBDA);
setState(842);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) {
{
setState(841);
varargslist();
}
}
setState(844);
match(COLON);
setState(845);
test_nocond();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 Or_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_or_test; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitOr_test(this);
else return visitor.visitChildren(this);
}
}
public final Or_testContext or_test() throws RecognitionException {
Or_testContext _localctx = new Or_testContext(_ctx, getState());
enterRule(_localctx, 146, RULE_or_test);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(847);
and_test();
setState(852);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(848);
match(OR);
setState(849);
and_test();
}
}
setState(854);
_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;
}
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 And_testContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and_test; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAnd_test(this);
else return visitor.visitChildren(this);
}
}
public final And_testContext and_test() throws RecognitionException {
And_testContext _localctx = new And_testContext(_ctx, getState());
enterRule(_localctx, 148, RULE_and_test);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(855);
not_test();
setState(860);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(856);
match(AND);
setState(857);
not_test();
}
}
setState(862);
_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;
}
public static class Not_testContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitNot_test(this);
else return visitor.visitChildren(this);
}
}
public final Not_testContext not_test() throws RecognitionException {
Not_testContext _localctx = new Not_testContext(_ctx, getState());
enterRule(_localctx, 150, RULE_not_test);
try {
setState(866);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
enterOuterAlt(_localctx, 1);
{
setState(863);
match(NOT);
setState(864);
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(865);
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;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonContext comparison() throws RecognitionException {
ComparisonContext _localctx = new ComparisonContext(_ctx, getState());
enterRule(_localctx, 152, RULE_comparison);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(868);
expr();
setState(874);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (IN - 18)) | (1L << (NOT - 18)) | (1L << (IS - 18)) | (1L << (LESS_THAN - 18)) | (1L << (GREATER_THAN - 18)) | (1L << (EQUALS - 18)) | (1L << (GT_EQ - 18)) | (1L << (LT_EQ - 18)) | (1L << (NOT_EQ_1 - 18)) | (1L << (NOT_EQ_2 - 18)))) != 0)) {
{
{
setState(869);
comp_op();
setState(870);
expr();
}
}
setState(876);
_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;
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitComp_op(this);
else return visitor.visitChildren(this);
}
}
public final Comp_opContext comp_op() throws RecognitionException {
Comp_opContext _localctx = new Comp_opContext(_ctx, getState());
enterRule(_localctx, 154, RULE_comp_op);
try {
setState(890);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(877);
match(LESS_THAN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(878);
match(GREATER_THAN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(879);
match(EQUALS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(880);
match(GT_EQ);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(881);
match(LT_EQ);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(882);
match(NOT_EQ_1);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(883);
match(NOT_EQ_2);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(884);
match(IN);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(885);
match(NOT);
setState(886);
match(IN);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(887);
match(IS);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(888);
match(IS);
setState(889);
match(NOT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Star_exprContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitStar_expr(this);
else return visitor.visitChildren(this);
}
}
public final Star_exprContext star_expr() throws RecognitionException {
Star_exprContext _localctx = new Star_exprContext(_ctx, getState());
enterRule(_localctx, 156, RULE_star_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(892);
match(STAR);
setState(893);
expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 158, RULE_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(895);
xor_expr();
setState(900);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR_OP) {
{
{
setState(896);
match(OR_OP);
setState(897);
xor_expr();
}
}
setState(902);
_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;
}
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 Xor_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xor_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitXor_expr(this);
else return visitor.visitChildren(this);
}
}
public final Xor_exprContext xor_expr() throws RecognitionException {
Xor_exprContext _localctx = new Xor_exprContext(_ctx, getState());
enterRule(_localctx, 160, RULE_xor_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(903);
and_expr();
setState(908);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==XOR) {
{
{
setState(904);
match(XOR);
setState(905);
and_expr();
}
}
setState(910);
_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;
}
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 And_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAnd_expr(this);
else return visitor.visitChildren(this);
}
}
public final And_exprContext and_expr() throws RecognitionException {
And_exprContext _localctx = new And_exprContext(_ctx, getState());
enterRule(_localctx, 162, RULE_and_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(911);
shift_expr();
setState(916);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND_OP) {
{
{
setState(912);
match(AND_OP);
setState(913);
shift_expr();
}
}
setState(918);
_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;
}
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 shift_op() {
return getRuleContexts(Shift_opContext.class);
}
public Shift_opContext shift_op(int i) {
return getRuleContext(Shift_opContext.class,i);
}
public Shift_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shift_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitShift_expr(this);
else return visitor.visitChildren(this);
}
}
public final Shift_exprContext shift_expr() throws RecognitionException {
Shift_exprContext _localctx = new Shift_exprContext(_ctx, getState());
enterRule(_localctx, 164, RULE_shift_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(919);
arith_expr();
setState(925);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LEFT_SHIFT || _la==RIGHT_SHIFT) {
{
{
setState(920);
shift_op();
setState(921);
arith_expr();
}
}
setState(927);
_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;
}
public static class Shift_opContext extends ParserRuleContext {
public TerminalNode LEFT_SHIFT() { return getToken(Python3Parser.LEFT_SHIFT, 0); }
public TerminalNode RIGHT_SHIFT() { return getToken(Python3Parser.RIGHT_SHIFT, 0); }
public Shift_opContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shift_op; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitShift_op(this);
else return visitor.visitChildren(this);
}
}
public final Shift_opContext shift_op() throws RecognitionException {
Shift_opContext _localctx = new Shift_opContext(_ctx, getState());
enterRule(_localctx, 166, RULE_shift_op);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(928);
_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();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 arith_op() {
return getRuleContexts(Arith_opContext.class);
}
public Arith_opContext arith_op(int i) {
return getRuleContext(Arith_opContext.class,i);
}
public Arith_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arith_expr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArith_expr(this);
else return visitor.visitChildren(this);
}
}
public final Arith_exprContext arith_expr() throws RecognitionException {
Arith_exprContext _localctx = new Arith_exprContext(_ctx, getState());
enterRule(_localctx, 168, RULE_arith_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(930);
term();
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ADD || _la==MINUS) {
{
{
setState(931);
arith_op();
setState(932);
term();
}
}
setState(938);
_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;
}
public static class Arith_opContext extends ParserRuleContext {
public TerminalNode ADD() { return getToken(Python3Parser.ADD, 0); }
public TerminalNode MINUS() { return getToken(Python3Parser.MINUS, 0); }
public Arith_opContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arith_op; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArith_op(this);
else return visitor.visitChildren(this);
}
}
public final Arith_opContext arith_op() throws RecognitionException {
Arith_opContext _localctx = new Arith_opContext(_ctx, getState());
enterRule(_localctx, 170, RULE_arith_op);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(939);
_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();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
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 term_op() {
return getRuleContexts(Term_opContext.class);
}
public Term_opContext term_op(int i) {
return getRuleContext(Term_opContext.class,i);
}
public TermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_term; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTerm(this);
else return visitor.visitChildren(this);
}
}
public final TermContext term() throws RecognitionException {
TermContext _localctx = new TermContext(_ctx, getState());
enterRule(_localctx, 172, RULE_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(941);
factor();
setState(947);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (STAR - 51)) | (1L << (DIV - 51)) | (1L << (MOD - 51)) | (1L << (IDIV - 51)) | (1L << (AT - 51)))) != 0)) {
{
{
setState(942);
term_op();
setState(943);
factor();
}
}
setState(949);
_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;
}
public static class Term_opContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); }
public TerminalNode AT() { return getToken(Python3Parser.AT, 0); }
public TerminalNode DIV() { return getToken(Python3Parser.DIV, 0); }
public TerminalNode MOD() { return getToken(Python3Parser.MOD, 0); }
public TerminalNode IDIV() { return getToken(Python3Parser.IDIV, 0); }
public Term_opContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_term_op; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTerm_op(this);
else return visitor.visitChildren(this);
}
}
public final Term_opContext term_op() throws RecognitionException {
Term_opContext _localctx = new Term_opContext(_ctx, getState());
enterRule(_localctx, 174, RULE_term_op);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(950);
_la = _input.LA(1);
if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (STAR - 51)) | (1L << (DIV - 51)) | (1L << (MOD - 51)) | (1L << (IDIV - 51)) | (1L << (AT - 51)))) != 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;
}
public static class FactorContext extends ParserRuleContext {
public Factor_opContext factor_op() {
return getRuleContext(Factor_opContext.class,0);
}
public FactorContext factor() {
return getRuleContext(FactorContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitFactor(this);
else return visitor.visitChildren(this);
}
}
public final FactorContext factor() throws RecognitionException {
FactorContext _localctx = new FactorContext(_ctx, getState());
enterRule(_localctx, 176, RULE_factor);
try {
setState(956);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ADD:
case MINUS:
case NOT_OP:
enterOuterAlt(_localctx, 1);
{
setState(952);
factor_op();
setState(953);
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(955);
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;
}
public static class Factor_opContext extends ParserRuleContext {
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 Factor_opContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_factor_op; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitFactor_op(this);
else return visitor.visitChildren(this);
}
}
public final Factor_opContext factor_op() throws RecognitionException {
Factor_opContext _localctx = new Factor_opContext(_ctx, getState());
enterRule(_localctx, 178, RULE_factor_op);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(958);
_la = _input.LA(1);
if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)))) != 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;
}
public static class PowerContext extends ParserRuleContext {
public AwaitContext await() {
return getRuleContext(AwaitContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitPower(this);
else return visitor.visitChildren(this);
}
}
public final PowerContext power() throws RecognitionException {
PowerContext _localctx = new PowerContext(_ctx, getState());
enterRule(_localctx, 180, RULE_power);
try {
enterOuterAlt(_localctx, 1);
{
setState(960);
await();
setState(963);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
{
setState(961);
match(POWER);
setState(962);
factor();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AwaitContext extends ParserRuleContext {
public Atom_exprContext atom_expr() {
return getRuleContext(Atom_exprContext.class,0);
}
public TerminalNode AWAIT() { return getToken(Python3Parser.AWAIT, 0); }
public AwaitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_await; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAwait(this);
else return visitor.visitChildren(this);
}
}
public final AwaitContext await() throws RecognitionException {
AwaitContext _localctx = new AwaitContext(_ctx, getState());
enterRule(_localctx, 182, RULE_await);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(966);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AWAIT) {
{
setState(965);
match(AWAIT);
}
}
setState(968);
atom_expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Atom_exprContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public AtomContext atom() {
return getRuleContext(AtomContext.class,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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAtom_expr(this);
else return visitor.visitChildren(this);
}
}
public final Atom_exprContext atom_expr() throws RecognitionException {
Atom_exprContext _localctx = new Atom_exprContext(_ctx, getState());
enterRule(_localctx, 184, RULE_atom_expr);
int _la;
try {
setState(981);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(970);
match(OPEN_PAREN);
setState(971);
test();
setState(972);
match(CLOSE_PAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(974);
atom();
setState(978);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DOT) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0)) {
{
{
setState(975);
trailer();
}
}
setState(980);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomContext extends ParserRuleContext {
public TupleContext tuple() {
return getRuleContext(TupleContext.class,0);
}
public ListContext list() {
return getRuleContext(ListContext.class,0);
}
public DictionaryOrSetContext dictionaryOrSet() {
return getRuleContext(DictionaryOrSetContext.class,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 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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitAtom(this);
else return visitor.visitChildren(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 186, RULE_atom);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(997);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAREN:
{
setState(983);
tuple();
}
break;
case OPEN_BRACK:
{
setState(984);
list();
}
break;
case OPEN_BRACE:
{
setState(985);
dictionaryOrSet();
}
break;
case NAME:
{
setState(986);
match(NAME);
}
break;
case NUMBER:
{
setState(987);
match(NUMBER);
}
break;
case STRING:
{
setState(989);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(988);
match(STRING);
}
}
setState(991);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==STRING );
}
break;
case ELLIPSIS:
{
setState(993);
match(ELLIPSIS);
}
break;
case NONE:
{
setState(994);
match(NONE);
}
break;
case TRUE:
{
setState(995);
match(TRUE);
}
break;
case FALSE:
{
setState(996);
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;
}
public static class TrailerContext extends ParserRuleContext {
public TrailerCallContext trailerCall() {
return getRuleContext(TrailerCallContext.class,0);
}
public TrailerSubscriptContext trailerSubscript() {
return getRuleContext(TrailerSubscriptContext.class,0);
}
public TrailerNameContext trailerName() {
return getRuleContext(TrailerNameContext.class,0);
}
public TrailerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailer; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTrailer(this);
else return visitor.visitChildren(this);
}
}
public final TrailerContext trailer() throws RecognitionException {
TrailerContext _localctx = new TrailerContext(_ctx, getState());
enterRule(_localctx, 188, RULE_trailer);
try {
setState(1002);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OPEN_PAREN:
enterOuterAlt(_localctx, 1);
{
setState(999);
trailerCall();
}
break;
case OPEN_BRACK:
enterOuterAlt(_localctx, 2);
{
setState(1000);
trailerSubscript();
}
break;
case DOT:
enterOuterAlt(_localctx, 3);
{
setState(1001);
trailerName();
}
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 class TrailerCallContext extends ParserRuleContext {
public ArglistContext arglist() {
return getRuleContext(ArglistContext.class,0);
}
public TrailerCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailerCall; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTrailerCall(this);
else return visitor.visitChildren(this);
}
}
public final TrailerCallContext trailerCall() throws RecognitionException {
TrailerCallContext _localctx = new TrailerCallContext(_ctx, getState());
enterRule(_localctx, 190, RULE_trailerCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1004);
match(OPEN_PAREN);
setState(1006);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1005);
arglist();
}
}
setState(1008);
match(CLOSE_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrailerSubscriptContext extends ParserRuleContext {
public SubscriptlistContext subscriptlist() {
return getRuleContext(SubscriptlistContext.class,0);
}
public TrailerSubscriptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailerSubscript; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTrailerSubscript(this);
else return visitor.visitChildren(this);
}
}
public final TrailerSubscriptContext trailerSubscript() throws RecognitionException {
TrailerSubscriptContext _localctx = new TrailerSubscriptContext(_ctx, getState());
enterRule(_localctx, 192, RULE_trailerSubscript);
try {
enterOuterAlt(_localctx, 1);
{
setState(1010);
match(OPEN_BRACK);
setState(1011);
subscriptlist();
setState(1012);
match(CLOSE_BRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrailerNameContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public TrailerNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailerName; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTrailerName(this);
else return visitor.visitChildren(this);
}
}
public final TrailerNameContext trailerName() throws RecognitionException {
TrailerNameContext _localctx = new TrailerNameContext(_ctx, getState());
enterRule(_localctx, 194, RULE_trailerName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1014);
match(DOT);
setState(1015);
match(NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TupleContext extends ParserRuleContext {
public Testlist_compTupleContext testlist_compTuple() {
return getRuleContext(Testlist_compTupleContext.class,0);
}
public TupleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tuple; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTuple(this);
else return visitor.visitChildren(this);
}
}
public final TupleContext tuple() throws RecognitionException {
TupleContext _localctx = new TupleContext(_ctx, getState());
enterRule(_localctx, 196, RULE_tuple);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1017);
match(OPEN_PAREN);
setState(1019);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << YIELD) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1018);
testlist_compTuple();
}
}
setState(1021);
match(CLOSE_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Testlist_compTupleContext extends ParserRuleContext {
public Yield_exprContext yield_expr() {
return getRuleContext(Yield_exprContext.class,0);
}
public TestOrStar_exprContext testOrStar_expr() {
return getRuleContext(TestOrStar_exprContext.class,0);
}
public List comp_for() {
return getRuleContexts(Comp_forContext.class);
}
public Comp_forContext comp_for(int i) {
return getRuleContext(Comp_forContext.class,i);
}
public List testOrStarList_expr() {
return getRuleContexts(TestOrStarList_exprContext.class);
}
public TestOrStarList_exprContext testOrStarList_expr(int i) {
return getRuleContext(TestOrStarList_exprContext.class,i);
}
public Testlist_compTupleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist_compTuple; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTestlist_compTuple(this);
else return visitor.visitChildren(this);
}
}
public final Testlist_compTupleContext testlist_compTuple() throws RecognitionException {
Testlist_compTupleContext _localctx = new Testlist_compTupleContext(_ctx, getState());
enterRule(_localctx, 198, RULE_testlist_compTuple);
int _la;
try {
int _alt;
setState(1043);
_errHandler.sync(this);
switch (_input.LA(1)) {
case YIELD:
enterOuterAlt(_localctx, 1);
{
setState(1023);
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:
enterOuterAlt(_localctx, 2);
{
setState(1024);
testOrStar_expr();
setState(1041);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1028);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOR || _la==ASYNC) {
{
{
setState(1025);
comp_for();
}
}
setState(1030);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1035);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,122,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1031);
match(COMMA);
setState(1032);
testOrStarList_expr();
}
}
}
setState(1037);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,122,_ctx);
}
setState(1039);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1038);
match(COMMA);
}
}
}
break;
}
}
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 class ListContext extends ParserRuleContext {
public Testlist_compListContext testlist_compList() {
return getRuleContext(Testlist_compListContext.class,0);
}
public ListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_list; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitList(this);
else return visitor.visitChildren(this);
}
}
public final ListContext list() throws RecognitionException {
ListContext _localctx = new ListContext(_ctx, getState());
enterRule(_localctx, 200, RULE_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1045);
match(OPEN_BRACK);
setState(1047);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1046);
testlist_compList();
}
}
setState(1049);
match(CLOSE_BRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Testlist_compListContext extends ParserRuleContext {
public TestOrStar_exprContext testOrStar_expr() {
return getRuleContext(TestOrStar_exprContext.class,0);
}
public List comp_for() {
return getRuleContexts(Comp_forContext.class);
}
public Comp_forContext comp_for(int i) {
return getRuleContext(Comp_forContext.class,i);
}
public List testOrStarList_expr() {
return getRuleContexts(TestOrStarList_exprContext.class);
}
public TestOrStarList_exprContext testOrStarList_expr(int i) {
return getRuleContext(TestOrStarList_exprContext.class,i);
}
public Testlist_compListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist_compList; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTestlist_compList(this);
else return visitor.visitChildren(this);
}
}
public final Testlist_compListContext testlist_compList() throws RecognitionException {
Testlist_compListContext _localctx = new Testlist_compListContext(_ctx, getState());
enterRule(_localctx, 202, RULE_testlist_compList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1051);
testOrStar_expr();
setState(1068);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) {
case 1:
{
setState(1055);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOR || _la==ASYNC) {
{
{
setState(1052);
comp_for();
}
}
setState(1057);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1062);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1058);
match(COMMA);
setState(1059);
testOrStarList_expr();
}
}
}
setState(1064);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,128,_ctx);
}
setState(1066);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1065);
match(COMMA);
}
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DictionaryOrSetContext extends ParserRuleContext {
public DictorsetmakerContext dictorsetmaker() {
return getRuleContext(DictorsetmakerContext.class,0);
}
public DictionaryOrSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dictionaryOrSet; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDictionaryOrSet(this);
else return visitor.visitChildren(this);
}
}
public final DictionaryOrSetContext dictionaryOrSet() throws RecognitionException {
DictionaryOrSetContext _localctx = new DictionaryOrSetContext(_ctx, getState());
enterRule(_localctx, 204, RULE_dictionaryOrSet);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1070);
match(OPEN_BRACE);
setState(1072);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1071);
dictorsetmaker();
}
}
setState(1074);
match(CLOSE_BRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DictorsetmakerContext extends ParserRuleContext {
public DictFirstContext dictFirst() {
return getRuleContext(DictFirstContext.class,0);
}
public SetFirstContext setFirst() {
return getRuleContext(SetFirstContext.class,0);
}
public List comp_for() {
return getRuleContexts(Comp_forContext.class);
}
public Comp_forContext comp_for(int i) {
return getRuleContext(Comp_forContext.class,i);
}
public List dicts() {
return getRuleContexts(DictsContext.class);
}
public DictsContext dicts(int i) {
return getRuleContext(DictsContext.class,i);
}
public List sets() {
return getRuleContexts(SetsContext.class);
}
public SetsContext sets(int i) {
return getRuleContext(SetsContext.class,i);
}
public DictorsetmakerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dictorsetmaker; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDictorsetmaker(this);
else return visitor.visitChildren(this);
}
}
public final DictorsetmakerContext dictorsetmaker() throws RecognitionException {
DictorsetmakerContext _localctx = new DictorsetmakerContext(_ctx, getState());
enterRule(_localctx, 206, RULE_dictorsetmaker);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1114);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
{
setState(1076);
dictFirst();
setState(1093);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) {
case 1:
{
setState(1080);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOR || _la==ASYNC) {
{
{
setState(1077);
comp_for();
}
}
setState(1082);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1087);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1083);
match(COMMA);
setState(1084);
dicts();
}
}
}
setState(1089);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
}
setState(1091);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1090);
match(COMMA);
}
}
}
break;
}
}
}
break;
case 2:
{
{
setState(1095);
setFirst();
setState(1112);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1099);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOR || _la==ASYNC) {
{
{
setState(1096);
comp_for();
}
}
setState(1101);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1106);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1102);
match(COMMA);
setState(1103);
sets();
}
}
}
setState(1108);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
}
setState(1110);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1109);
match(COMMA);
}
}
}
break;
}
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DictFirstContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public DictFirstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dictFirst; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDictFirst(this);
else return visitor.visitChildren(this);
}
}
public final DictFirstContext dictFirst() throws RecognitionException {
DictFirstContext _localctx = new DictFirstContext(_ctx, getState());
enterRule(_localctx, 208, RULE_dictFirst);
try {
setState(1122);
_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:
enterOuterAlt(_localctx, 1);
{
setState(1116);
test();
setState(1117);
match(COLON);
setState(1118);
test();
}
break;
case POWER:
enterOuterAlt(_localctx, 2);
{
setState(1120);
match(POWER);
setState(1121);
expr();
}
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 class DictsContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public DictsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dicts; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitDicts(this);
else return visitor.visitChildren(this);
}
}
public final DictsContext dicts() throws RecognitionException {
DictsContext _localctx = new DictsContext(_ctx, getState());
enterRule(_localctx, 210, RULE_dicts);
try {
setState(1130);
_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:
enterOuterAlt(_localctx, 1);
{
setState(1124);
test();
setState(1125);
match(COLON);
setState(1126);
test();
}
break;
case POWER:
enterOuterAlt(_localctx, 2);
{
setState(1128);
match(POWER);
setState(1129);
expr();
}
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 class SetFirstContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public Star_exprContext star_expr() {
return getRuleContext(Star_exprContext.class,0);
}
public SetFirstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setFirst; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSetFirst(this);
else return visitor.visitChildren(this);
}
}
public final SetFirstContext setFirst() throws RecognitionException {
SetFirstContext _localctx = new SetFirstContext(_ctx, getState());
enterRule(_localctx, 212, RULE_setFirst);
try {
setState(1134);
_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:
enterOuterAlt(_localctx, 1);
{
setState(1132);
test();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(1133);
star_expr();
}
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 class SetsContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public Star_exprContext star_expr() {
return getRuleContext(Star_exprContext.class,0);
}
public SetsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sets; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSets(this);
else return visitor.visitChildren(this);
}
}
public final SetsContext sets() throws RecognitionException {
SetsContext _localctx = new SetsContext(_ctx, getState());
enterRule(_localctx, 214, RULE_sets);
try {
setState(1138);
_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:
enterOuterAlt(_localctx, 1);
{
setState(1136);
test();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(1137);
star_expr();
}
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 class SubscriptlistContext extends ParserRuleContext {
public List subscript() {
return getRuleContexts(SubscriptContext.class);
}
public SubscriptContext subscript(int i) {
return getRuleContext(SubscriptContext.class,i);
}
public SubscriptlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subscriptlist; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSubscriptlist(this);
else return visitor.visitChildren(this);
}
}
public final SubscriptlistContext subscriptlist() throws RecognitionException {
SubscriptlistContext _localctx = new SubscriptlistContext(_ctx, getState());
enterRule(_localctx, 216, RULE_subscriptlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1140);
subscript();
setState(1145);
_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(1141);
match(COMMA);
setState(1142);
subscript();
}
}
}
setState(1147);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,145,_ctx);
}
setState(1149);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1148);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubscriptContext extends ParserRuleContext {
public SubscriptIndexContext subscriptIndex() {
return getRuleContext(SubscriptIndexContext.class,0);
}
public SubscriptSliceContext subscriptSlice() {
return getRuleContext(SubscriptSliceContext.class,0);
}
public SubscriptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subscript; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSubscript(this);
else return visitor.visitChildren(this);
}
}
public final SubscriptContext subscript() throws RecognitionException {
SubscriptContext _localctx = new SubscriptContext(_ctx, getState());
enterRule(_localctx, 218, RULE_subscript);
try {
setState(1153);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1151);
subscriptIndex();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1152);
subscriptSlice();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubscriptIndexContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public SubscriptIndexContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subscriptIndex; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSubscriptIndex(this);
else return visitor.visitChildren(this);
}
}
public final SubscriptIndexContext subscriptIndex() throws RecognitionException {
SubscriptIndexContext _localctx = new SubscriptIndexContext(_ctx, getState());
enterRule(_localctx, 220, RULE_subscriptIndex);
try {
enterOuterAlt(_localctx, 1);
{
setState(1155);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubscriptSliceContext extends ParserRuleContext {
public SlicelLowerContext slicelLower() {
return getRuleContext(SlicelLowerContext.class,0);
}
public SliceUpperContext sliceUpper() {
return getRuleContext(SliceUpperContext.class,0);
}
public SliceStepContext sliceStep() {
return getRuleContext(SliceStepContext.class,0);
}
public SubscriptSliceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subscriptSlice; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSubscriptSlice(this);
else return visitor.visitChildren(this);
}
}
public final SubscriptSliceContext subscriptSlice() throws RecognitionException {
SubscriptSliceContext _localctx = new SubscriptSliceContext(_ctx, getState());
enterRule(_localctx, 222, RULE_subscriptSlice);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1157);
slicelLower();
setState(1158);
match(COLON);
setState(1159);
sliceUpper();
setState(1161);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1160);
sliceStep();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SlicelLowerContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public SlicelLowerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_slicelLower; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSlicelLower(this);
else return visitor.visitChildren(this);
}
}
public final SlicelLowerContext slicelLower() throws RecognitionException {
SlicelLowerContext _localctx = new SlicelLowerContext(_ctx, getState());
enterRule(_localctx, 224, RULE_slicelLower);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1164);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1163);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SliceUpperContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public SliceUpperContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sliceUpper; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSliceUpper(this);
else return visitor.visitChildren(this);
}
}
public final SliceUpperContext sliceUpper() throws RecognitionException {
SliceUpperContext _localctx = new SliceUpperContext(_ctx, getState());
enterRule(_localctx, 226, RULE_sliceUpper);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1167);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1166);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SliceStepContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public SliceStepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sliceStep; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitSliceStep(this);
else return visitor.visitChildren(this);
}
}
public final SliceStepContext sliceStep() throws RecognitionException {
SliceStepContext _localctx = new SliceStepContext(_ctx, getState());
enterRule(_localctx, 228, RULE_sliceStep);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1169);
match(COLON);
setState(1171);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1170);
test();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprlistContext extends ParserRuleContext {
public List exprOrStarExpr() {
return getRuleContexts(ExprOrStarExprContext.class);
}
public ExprOrStarExprContext exprOrStarExpr(int i) {
return getRuleContext(ExprOrStarExprContext.class,i);
}
public ExprlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprlist; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExprlist(this);
else return visitor.visitChildren(this);
}
}
public final ExprlistContext exprlist() throws RecognitionException {
ExprlistContext _localctx = new ExprlistContext(_ctx, getState());
enterRule(_localctx, 230, RULE_exprlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1173);
exprOrStarExpr();
setState(1178);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,152,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1174);
match(COMMA);
setState(1175);
exprOrStarExpr();
}
}
}
setState(1180);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,152,_ctx);
}
setState(1182);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1181);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprOrStarExprContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Star_exprContext star_expr() {
return getRuleContext(Star_exprContext.class,0);
}
public ExprOrStarExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprOrStarExpr; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitExprOrStarExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprOrStarExprContext exprOrStarExpr() throws RecognitionException {
ExprOrStarExprContext _localctx = new ExprOrStarExprContext(_ctx, getState());
enterRule(_localctx, 232, RULE_exprOrStarExpr);
try {
setState(1186);
_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:
enterOuterAlt(_localctx, 1);
{
setState(1184);
expr();
}
break;
case STAR:
enterOuterAlt(_localctx, 2);
{
setState(1185);
star_expr();
}
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 class TestlistContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public TestlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_testlist; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitTestlist(this);
else return visitor.visitChildren(this);
}
}
public final TestlistContext testlist() throws RecognitionException {
TestlistContext _localctx = new TestlistContext(_ctx, getState());
enterRule(_localctx, 234, RULE_testlist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1188);
test();
setState(1193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,155,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1189);
match(COMMA);
setState(1190);
test();
}
}
}
setState(1195);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,155,_ctx);
}
setState(1197);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1196);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassdefContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); }
public SuiteContext suite() {
return getRuleContext(SuiteContext.class,0);
}
public List decorator() {
return getRuleContexts(DecoratorContext.class);
}
public DecoratorContext decorator(int i) {
return getRuleContext(DecoratorContext.class,i);
}
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitClassdef(this);
else return visitor.visitChildren(this);
}
}
public final ClassdefContext classdef() throws RecognitionException {
ClassdefContext _localctx = new ClassdefContext(_ctx, getState());
enterRule(_localctx, 236, RULE_classdef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1202);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1199);
decorator();
}
}
setState(1204);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1205);
match(CLASS);
setState(1206);
match(NAME);
setState(1212);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OPEN_PAREN) {
{
setState(1207);
match(OPEN_PAREN);
setState(1209);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1208);
arglist();
}
}
setState(1211);
match(CLOSE_PAREN);
}
}
setState(1214);
match(COLON);
setState(1215);
suite();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArglistContext extends ParserRuleContext {
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public ArglistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arglist; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArglist(this);
else return visitor.visitChildren(this);
}
}
public final ArglistContext arglist() throws RecognitionException {
ArglistContext _localctx = new ArglistContext(_ctx, getState());
enterRule(_localctx, 238, RULE_arglist);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1217);
argument();
setState(1222);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1218);
match(COMMA);
setState(1219);
argument();
}
}
}
setState(1224);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
}
setState(1226);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1225);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentContext extends ParserRuleContext {
public ArgumentNormalContext argumentNormal() {
return getRuleContext(ArgumentNormalContext.class,0);
}
public ArgumentKeywordContext argumentKeyword() {
return getRuleContext(ArgumentKeywordContext.class,0);
}
public ArgumentStarContext argumentStar() {
return getRuleContext(ArgumentStarContext.class,0);
}
public ArgumentDoubleStarContext argumentDoubleStar() {
return getRuleContext(ArgumentDoubleStarContext.class,0);
}
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArgument(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 240, RULE_argument);
try {
enterOuterAlt(_localctx, 1);
{
setState(1232);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1228);
argumentNormal();
}
break;
case 2:
{
setState(1229);
argumentKeyword();
}
break;
case 3:
{
setState(1230);
argumentStar();
}
break;
case 4:
{
setState(1231);
argumentDoubleStar();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentNormalContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public List comp_for() {
return getRuleContexts(Comp_forContext.class);
}
public Comp_forContext comp_for(int i) {
return getRuleContext(Comp_forContext.class,i);
}
public ArgumentNormalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentNormal; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArgumentNormal(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentNormalContext argumentNormal() throws RecognitionException {
ArgumentNormalContext _localctx = new ArgumentNormalContext(_ctx, getState());
enterRule(_localctx, 242, RULE_argumentNormal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1234);
test();
setState(1238);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FOR || _la==ASYNC) {
{
{
setState(1235);
comp_for();
}
}
setState(1240);
_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;
}
public static class ArgumentKeywordContext extends ParserRuleContext {
public List test() {
return getRuleContexts(TestContext.class);
}
public TestContext test(int i) {
return getRuleContext(TestContext.class,i);
}
public ArgumentKeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentKeyword; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArgumentKeyword(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentKeywordContext argumentKeyword() throws RecognitionException {
ArgumentKeywordContext _localctx = new ArgumentKeywordContext(_ctx, getState());
enterRule(_localctx, 244, RULE_argumentKeyword);
try {
enterOuterAlt(_localctx, 1);
{
setState(1241);
test();
setState(1242);
match(ASSIGN);
setState(1243);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentStarContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public ArgumentStarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentStar; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArgumentStar(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentStarContext argumentStar() throws RecognitionException {
ArgumentStarContext _localctx = new ArgumentStarContext(_ctx, getState());
enterRule(_localctx, 246, RULE_argumentStar);
try {
enterOuterAlt(_localctx, 1);
{
setState(1245);
match(STAR);
setState(1246);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentDoubleStarContext extends ParserRuleContext {
public TestContext test() {
return getRuleContext(TestContext.class,0);
}
public ArgumentDoubleStarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentDoubleStar; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitArgumentDoubleStar(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentDoubleStarContext argumentDoubleStar() throws RecognitionException {
ArgumentDoubleStarContext _localctx = new ArgumentDoubleStarContext(_ctx, getState());
enterRule(_localctx, 248, RULE_argumentDoubleStar);
try {
enterOuterAlt(_localctx, 1);
{
setState(1248);
match(POWER);
setState(1249);
test();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Comp_forContext extends ParserRuleContext {
public ExprlistContext exprlist() {
return getRuleContext(ExprlistContext.class,0);
}
public Or_testContext or_test() {
return getRuleContext(Or_testContext.class,0);
}
public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); }
public List comp_if() {
return getRuleContexts(Comp_ifContext.class);
}
public Comp_ifContext comp_if(int i) {
return getRuleContext(Comp_ifContext.class,i);
}
public Comp_forContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_for; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitComp_for(this);
else return visitor.visitChildren(this);
}
}
public final Comp_forContext comp_for() throws RecognitionException {
Comp_forContext _localctx = new Comp_forContext(_ctx, getState());
enterRule(_localctx, 250, RULE_comp_for);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASYNC) {
{
setState(1251);
match(ASYNC);
}
}
setState(1254);
match(FOR);
setState(1255);
exprlist();
setState(1256);
match(IN);
setState(1257);
or_test();
setState(1261);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IF) {
{
{
setState(1258);
comp_if();
}
}
setState(1263);
_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;
}
public static class Comp_ifContext extends ParserRuleContext {
public Test_nocondContext test_nocond() {
return getRuleContext(Test_nocondContext.class,0);
}
public Comp_ifContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_if; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitComp_if(this);
else return visitor.visitChildren(this);
}
}
public final Comp_ifContext comp_if() throws RecognitionException {
Comp_ifContext _localctx = new Comp_ifContext(_ctx, getState());
enterRule(_localctx, 252, RULE_comp_if);
try {
enterOuterAlt(_localctx, 1);
{
setState(1264);
match(IF);
setState(1265);
test_nocond();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Yield_exprContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitYield_expr(this);
else return visitor.visitChildren(this);
}
}
public final Yield_exprContext yield_expr() throws RecognitionException {
Yield_exprContext _localctx = new Yield_exprContext(_ctx, getState());
enterRule(_localctx, 254, RULE_yield_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1267);
match(YIELD);
setState(1269);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << FROM) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) {
{
setState(1268);
yield_arg();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Yield_argContext extends ParserRuleContext {
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 T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof Python3Visitor ) return ((Python3Visitor)visitor).visitYield_arg(this);
else return visitor.visitChildren(this);
}
}
public final Yield_argContext yield_arg() throws RecognitionException {
Yield_argContext _localctx = new Yield_argContext(_ctx, getState());
enterRule(_localctx, 256, RULE_yield_arg);
try {
setState(1274);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
enterOuterAlt(_localctx, 1);
{
setState(1271);
match(FROM);
setState(1272);
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(1273);
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 =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3e\u04ff\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\3\2\3\2\3\2\3\2\3\2\5\2\u010a\n\2\3\3"+
"\3\3\7\3\u010e\n\3\f\3\16\3\u0111\13\3\3\3\3\3\3\4\3\4\7\4\u0117\n\4\f"+
"\4\16\4\u011a\13\4\3\4\3\4\3\5\3\5\3\5\3\5\5\5\u0122\n\5\3\5\5\5\u0125"+
"\n\5\3\5\3\5\3\6\7\6\u012a\n\6\f\6\16\6\u012d\13\6\3\6\5\6\u0130\n\6\3"+
"\6\3\6\3\6\3\6\3\6\5\6\u0137\n\6\3\6\3\6\3\6\3\7\3\7\5\7\u013e\n\7\3\7"+
"\3\7\3\b\3\b\3\b\5\b\u0145\n\b\3\t\3\t\3\t\5\t\u014a\n\t\3\n\3\n\5\n\u014e"+
"\n\n\3\13\3\13\3\13\3\13\3\f\3\f\5\f\u0156\n\f\3\f\3\f\7\f\u015a\n\f\f"+
"\f\16\f\u015d\13\f\3\f\5\f\u0160\n\f\3\r\3\r\3\r\3\r\7\r\u0166\n\r\f\r"+
"\16\r\u0169\13\r\3\r\3\r\5\r\u016d\n\r\3\16\3\16\5\16\u0171\n\16\3\17"+
"\3\17\3\17\3\17\5\17\u0177\n\17\5\17\u0179\n\17\5\17\u017b\n\17\3\17\3"+
"\17\3\17\5\17\u0180\n\17\5\17\u0182\n\17\3\20\3\20\3\20\7\20\u0187\n\20"+
"\f\20\16\20\u018a\13\20\3\20\5\20\u018d\n\20\3\21\3\21\3\21\3\21\5\21"+
"\u0193\n\21\5\21\u0195\n\21\3\22\3\22\3\22\5\22\u019a\n\22\3\23\3\23\3"+
"\23\5\23\u019f\n\23\3\24\3\24\3\25\3\25\5\25\u01a5\n\25\3\26\3\26\3\26"+
"\3\26\3\27\3\27\5\27\u01ad\n\27\3\27\3\27\7\27\u01b1\n\27\f\27\16\27\u01b4"+
"\13\27\3\27\5\27\u01b7\n\27\3\30\3\30\3\30\3\30\7\30\u01bd\n\30\f\30\16"+
"\30\u01c0\13\30\3\30\3\30\5\30\u01c4\n\30\3\31\3\31\5\31\u01c8\n\31\3"+
"\32\3\32\3\32\3\32\5\32\u01ce\n\32\5\32\u01d0\n\32\5\32\u01d2\n\32\3\32"+
"\3\32\3\32\5\32\u01d7\n\32\5\32\u01d9\n\32\3\33\3\33\3\33\7\33\u01de\n"+
"\33\f\33\16\33\u01e1\13\33\3\33\5\33\u01e4\n\33\3\34\3\34\3\34\3\34\5"+
"\34\u01ea\n\34\5\34\u01ec\n\34\3\35\3\35\3\35\5\35\u01f1\n\35\3\36\3\36"+
"\5\36\u01f5\n\36\3\37\3\37\3\37\7\37\u01fa\n\37\f\37\16\37\u01fd\13\37"+
"\3\37\5\37\u0200\n\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 \3 \5 \u020c\n \3"+
"!\3!\3!\5!\u0211\n!\3\"\3\"\3\"\3\"\3\"\5\"\u0218\n\"\5\"\u021a\n\"\3"+
"#\3#\3#\3#\3#\7#\u0221\n#\f#\16#\u0224\13#\3$\3$\5$\u0228\n$\3%\3%\3%"+
"\3%\5%\u022e\n%\3&\3&\3&\7&\u0233\n&\f&\16&\u0236\13&\3&\5&\u0239\n&\3"+
"\'\3\'\5\'\u023d\n\'\3(\3(\5(\u0241\n(\3)\3)\3*\3*\3*\3+\3+\3,\3,\3,\3"+
",\3,\5,\u024f\n,\3-\3-\3.\3.\3/\3/\5/\u0257\n/\3\60\3\60\3\61\3\61\3\61"+
"\3\61\5\61\u025f\n\61\5\61\u0261\n\61\3\62\3\62\5\62\u0265\n\62\3\63\3"+
"\63\3\63\3\64\3\64\7\64\u026c\n\64\f\64\16\64\u026f\13\64\3\64\3\64\6"+
"\64\u0273\n\64\r\64\16\64\u0274\5\64\u0277\n\64\3\64\3\64\3\64\3\64\3"+
"\64\3\64\3\64\5\64\u0280\n\64\3\65\3\65\3\65\5\65\u0285\n\65\3\66\3\66"+
"\3\66\5\66\u028a\n\66\3\67\3\67\3\67\7\67\u028f\n\67\f\67\16\67\u0292"+
"\13\67\3\67\5\67\u0295\n\67\38\38\38\78\u029a\n8\f8\168\u029d\138\39\3"+
"9\39\79\u02a2\n9\f9\169\u02a5\139\3:\3:\3:\3:\7:\u02ab\n:\f:\16:\u02ae"+
"\13:\3;\3;\3;\3;\7;\u02b4\n;\f;\16;\u02b7\13;\3<\3<\3<\3<\5<\u02bd\n<"+
"\3=\3=\3=\3=\3=\3=\3=\3=\5=\u02c7\n=\3>\3>\3>\3>\5>\u02cd\n>\3?\3?\3?"+
"\3?\3?\3?\3?\3?\3?\7?\u02d8\n?\f?\16?\u02db\13?\3?\3?\3?\5?\u02e0\n?\3"+
"@\3@\3@\3@\3@\3@\3@\5@\u02e9\n@\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u02f4\n"+
"A\3B\3B\3B\3B\3B\3B\3B\6B\u02fd\nB\rB\16B\u02fe\3B\3B\3B\5B\u0304\nB\3"+
"B\3B\3B\5B\u0309\nB\3B\3B\3B\5B\u030e\nB\3C\3C\3C\3C\7C\u0314\nC\fC\16"+
"C\u0317\13C\3C\3C\3C\3D\3D\3D\5D\u031f\nD\3E\3E\3E\3E\5E\u0325\nE\5E\u0327"+
"\nE\3F\3F\3F\3F\6F\u032d\nF\rF\16F\u032e\3F\3F\5F\u0333\nF\3G\3G\3G\3"+
"G\3G\3G\5G\u033b\nG\3G\5G\u033e\nG\3H\3H\5H\u0342\nH\3I\3I\5I\u0346\n"+
"I\3I\3I\3I\3J\3J\5J\u034d\nJ\3J\3J\3J\3K\3K\3K\7K\u0355\nK\fK\16K\u0358"+
"\13K\3L\3L\3L\7L\u035d\nL\fL\16L\u0360\13L\3M\3M\3M\5M\u0365\nM\3N\3N"+
"\3N\3N\7N\u036b\nN\fN\16N\u036e\13N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3"+
"O\3O\5O\u037d\nO\3P\3P\3P\3Q\3Q\3Q\7Q\u0385\nQ\fQ\16Q\u0388\13Q\3R\3R"+
"\3R\7R\u038d\nR\fR\16R\u0390\13R\3S\3S\3S\7S\u0395\nS\fS\16S\u0398\13"+
"S\3T\3T\3T\3T\7T\u039e\nT\fT\16T\u03a1\13T\3U\3U\3V\3V\3V\3V\7V\u03a9"+
"\nV\fV\16V\u03ac\13V\3W\3W\3X\3X\3X\3X\7X\u03b4\nX\fX\16X\u03b7\13X\3"+
"Y\3Y\3Z\3Z\3Z\3Z\5Z\u03bf\nZ\3[\3[\3\\\3\\\3\\\5\\\u03c6\n\\\3]\5]\u03c9"+
"\n]\3]\3]\3^\3^\3^\3^\3^\3^\7^\u03d3\n^\f^\16^\u03d6\13^\5^\u03d8\n^\3"+
"_\3_\3_\3_\3_\3_\6_\u03e0\n_\r_\16_\u03e1\3_\3_\3_\3_\5_\u03e8\n_\3`\3"+
"`\3`\5`\u03ed\n`\3a\3a\5a\u03f1\na\3a\3a\3b\3b\3b\3b\3c\3c\3c\3d\3d\5"+
"d\u03fe\nd\3d\3d\3e\3e\3e\7e\u0405\ne\fe\16e\u0408\13e\3e\3e\7e\u040c"+
"\ne\fe\16e\u040f\13e\3e\5e\u0412\ne\5e\u0414\ne\5e\u0416\ne\3f\3f\5f\u041a"+
"\nf\3f\3f\3g\3g\7g\u0420\ng\fg\16g\u0423\13g\3g\3g\7g\u0427\ng\fg\16g"+
"\u042a\13g\3g\5g\u042d\ng\5g\u042f\ng\3h\3h\5h\u0433\nh\3h\3h\3i\3i\7"+
"i\u0439\ni\fi\16i\u043c\13i\3i\3i\7i\u0440\ni\fi\16i\u0443\13i\3i\5i\u0446"+
"\ni\5i\u0448\ni\3i\3i\7i\u044c\ni\fi\16i\u044f\13i\3i\3i\7i\u0453\ni\f"+
"i\16i\u0456\13i\3i\5i\u0459\ni\5i\u045b\ni\5i\u045d\ni\3j\3j\3j\3j\3j"+
"\3j\5j\u0465\nj\3k\3k\3k\3k\3k\3k\5k\u046d\nk\3l\3l\5l\u0471\nl\3m\3m"+
"\5m\u0475\nm\3n\3n\3n\7n\u047a\nn\fn\16n\u047d\13n\3n\5n\u0480\nn\3o\3"+
"o\5o\u0484\no\3p\3p\3q\3q\3q\3q\5q\u048c\nq\3r\5r\u048f\nr\3s\5s\u0492"+
"\ns\3t\3t\5t\u0496\nt\3u\3u\3u\7u\u049b\nu\fu\16u\u049e\13u\3u\5u\u04a1"+
"\nu\3v\3v\5v\u04a5\nv\3w\3w\3w\7w\u04aa\nw\fw\16w\u04ad\13w\3w\5w\u04b0"+
"\nw\3x\7x\u04b3\nx\fx\16x\u04b6\13x\3x\3x\3x\3x\5x\u04bc\nx\3x\5x\u04bf"+
"\nx\3x\3x\3x\3y\3y\3y\7y\u04c7\ny\fy\16y\u04ca\13y\3y\5y\u04cd\ny\3z\3"+
"z\3z\3z\5z\u04d3\nz\3{\3{\7{\u04d7\n{\f{\16{\u04da\13{\3|\3|\3|\3|\3}"+
"\3}\3}\3~\3~\3~\3\177\5\177\u04e7\n\177\3\177\3\177\3\177\3\177\3\177"+
"\7\177\u04ee\n\177\f\177\16\177\u04f1\13\177\3\u0080\3\u0080\3\u0080\3"+
"\u0081\3\u0081\5\u0081\u04f8\n\u0081\3\u0082\3\u0082\3\u0082\5\u0082\u04fd"+
"\n\u0082\3\u0082\2\2\u0083\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$"+
"&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+
"\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+
"\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4"+
"\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc"+
"\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4"+
"\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc"+
"\u00fe\u0100\u0102\2\b\3\2Ua\3\2\63\64\3\2BC\3\2DE\5\2\65\65FHSS\4\2D"+
"EII\2\u054e\2\u0109\3\2\2\2\4\u010f\3\2\2\2\6\u0114\3\2\2\2\b\u011d\3"+
"\2\2\2\n\u012b\3\2\2\2\f\u013b\3\2\2\2\16\u0144\3\2\2\2\20\u0146\3\2\2"+
"\2\22\u014d\3\2\2\2\24\u014f\3\2\2\2\26\u0155\3\2\2\2\30\u0161\3\2\2\2"+
"\32\u016e\3\2\2\2\34\u0181\3\2\2\2\36\u0183\3\2\2\2 \u018e\3\2\2\2\"\u0196"+
"\3\2\2\2$\u019e\3\2\2\2&\u01a0\3\2\2\2(\u01a4\3\2\2\2*\u01a6\3\2\2\2,"+
"\u01ac\3\2\2\2.\u01b8\3\2\2\2\60\u01c5\3\2\2\2\62\u01d8\3\2\2\2\64\u01da"+
"\3\2\2\2\66\u01e5\3\2\2\28\u01ed\3\2\2\2:\u01f4\3\2\2\2<\u01f6\3\2\2\2"+
">\u020b\3\2\2\2@\u0210\3\2\2\2B\u0212\3\2\2\2D\u021b\3\2\2\2F\u0227\3"+
"\2\2\2H\u0229\3\2\2\2J\u022f\3\2\2\2L\u023c\3\2\2\2N\u0240\3\2\2\2P\u0242"+
"\3\2\2\2R\u0244\3\2\2\2T\u0247\3\2\2\2V\u024e\3\2\2\2X\u0250\3\2\2\2Z"+
"\u0252\3\2\2\2\\\u0254\3\2\2\2^\u0258\3\2\2\2`\u025a\3\2\2\2b\u0264\3"+
"\2\2\2d\u0266\3\2\2\2f\u0269\3\2\2\2h\u0281\3\2\2\2j\u0286\3\2\2\2l\u028b"+
"\3\2\2\2n\u0296\3\2\2\2p\u029e\3\2\2\2r\u02a6\3\2\2\2t\u02af\3\2\2\2v"+
"\u02b8\3\2\2\2x\u02c6\3\2\2\2z\u02c8\3\2\2\2|\u02ce\3\2\2\2~\u02e1\3\2"+
"\2\2\u0080\u02ea\3\2\2\2\u0082\u02f5\3\2\2\2\u0084\u030f\3\2\2\2\u0086"+
"\u031b\3\2\2\2\u0088\u0320\3\2\2\2\u008a\u0332\3\2\2\2\u008c\u033d\3\2"+
"\2\2\u008e\u0341\3\2\2\2\u0090\u0343\3\2\2\2\u0092\u034a\3\2\2\2\u0094"+
"\u0351\3\2\2\2\u0096\u0359\3\2\2\2\u0098\u0364\3\2\2\2\u009a\u0366\3\2"+
"\2\2\u009c\u037c\3\2\2\2\u009e\u037e\3\2\2\2\u00a0\u0381\3\2\2\2\u00a2"+
"\u0389\3\2\2\2\u00a4\u0391\3\2\2\2\u00a6\u0399\3\2\2\2\u00a8\u03a2\3\2"+
"\2\2\u00aa\u03a4\3\2\2\2\u00ac\u03ad\3\2\2\2\u00ae\u03af\3\2\2\2\u00b0"+
"\u03b8\3\2\2\2\u00b2\u03be\3\2\2\2\u00b4\u03c0\3\2\2\2\u00b6\u03c2\3\2"+
"\2\2\u00b8\u03c8\3\2\2\2\u00ba\u03d7\3\2\2\2\u00bc\u03e7\3\2\2\2\u00be"+
"\u03ec\3\2\2\2\u00c0\u03ee\3\2\2\2\u00c2\u03f4\3\2\2\2\u00c4\u03f8\3\2"+
"\2\2\u00c6\u03fb\3\2\2\2\u00c8\u0415\3\2\2\2\u00ca\u0417\3\2\2\2\u00cc"+
"\u041d\3\2\2\2\u00ce\u0430\3\2\2\2\u00d0\u045c\3\2\2\2\u00d2\u0464\3\2"+
"\2\2\u00d4\u046c\3\2\2\2\u00d6\u0470\3\2\2\2\u00d8\u0474\3\2\2\2\u00da"+
"\u0476\3\2\2\2\u00dc\u0483\3\2\2\2\u00de\u0485\3\2\2\2\u00e0\u0487\3\2"+
"\2\2\u00e2\u048e\3\2\2\2\u00e4\u0491\3\2\2\2\u00e6\u0493\3\2\2\2\u00e8"+
"\u0497\3\2\2\2\u00ea\u04a4\3\2\2\2\u00ec\u04a6\3\2\2\2\u00ee\u04b4\3\2"+
"\2\2\u00f0\u04c3\3\2\2\2\u00f2\u04d2\3\2\2\2\u00f4\u04d4\3\2\2\2\u00f6"+
"\u04db\3\2\2\2\u00f8\u04df\3\2\2\2\u00fa\u04e2\3\2\2\2\u00fc\u04e6\3\2"+
"\2\2\u00fe\u04f2\3\2\2\2\u0100\u04f5\3\2\2\2\u0102\u04fc\3\2\2\2\u0104"+
"\u010a\7)\2\2\u0105\u010a\5<\37\2\u0106\u0107\5x=\2\u0107\u0108\7)\2\2"+
"\u0108\u010a\3\2\2\2\u0109\u0104\3\2\2\2\u0109\u0105\3\2\2\2\u0109\u0106"+
"\3\2\2\2\u010a\3\3\2\2\2\u010b\u010e\7)\2\2\u010c\u010e\5:\36\2\u010d"+
"\u010b\3\2\2\2\u010d\u010c\3\2\2\2\u010e\u0111\3\2\2\2\u010f\u010d\3\2"+
"\2\2\u010f\u0110\3\2\2\2\u0110\u0112\3\2\2\2\u0111\u010f\3\2\2\2\u0112"+
"\u0113\7\2\2\3\u0113\5\3\2\2\2\u0114\u0118\5\u00ecw\2\u0115\u0117\7)\2"+
"\2\u0116\u0115\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0116\3\2\2\2\u0118\u0119"+
"\3\2\2\2\u0119\u011b\3\2\2\2\u011a\u0118\3\2\2\2\u011b\u011c\7\2\2\3\u011c"+
"\7\3\2\2\2\u011d\u011e\7S\2\2\u011e\u0124\5p9\2\u011f\u0121\7\66\2\2\u0120"+
"\u0122\5\u00f0y\2\u0121\u0120\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0123"+
"\3\2\2\2\u0123\u0125\7\67\2\2\u0124\u011f\3\2\2\2\u0124\u0125\3\2\2\2"+
"\u0125\u0126\3\2\2\2\u0126\u0127\7)\2\2\u0127\t\3\2\2\2\u0128\u012a\5"+
"\b\5\2\u0129\u0128\3\2\2\2\u012a\u012d\3\2\2\2\u012b\u0129\3\2\2\2\u012b"+
"\u012c\3\2\2\2\u012c\u012f\3\2\2\2\u012d\u012b\3\2\2\2\u012e\u0130\7\'"+
"\2\2\u012f\u012e\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131"+
"\u0132\7\6\2\2\u0132\u0133\7*\2\2\u0133\u0136\5\f\7\2\u0134\u0135\7T\2"+
"\2\u0135\u0137\5\u008cG\2\u0136\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137"+
"\u0138\3\2\2\2\u0138\u0139\79\2\2\u0139\u013a\5\u008aF\2\u013a\13\3\2"+
"\2\2\u013b\u013d\7\66\2\2\u013c\u013e\5\16\b\2\u013d\u013c\3\2\2\2\u013d"+
"\u013e\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0140\7\67\2\2\u0140\r\3\2\2"+
"\2\u0141\u0145\5\26\f\2\u0142\u0145\5\36\20\2\u0143\u0145\5\"\22\2\u0144"+
"\u0141\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0143\3\2\2\2\u0145\17\3\2\2"+
"\2\u0146\u0149\7*\2\2\u0147\u0148\79\2\2\u0148\u014a\5\u008cG\2\u0149"+
"\u0147\3\2\2\2\u0149\u014a\3\2\2\2\u014a\21\3\2\2\2\u014b\u014e\5\20\t"+
"\2\u014c\u014e\5\24\13\2\u014d\u014b\3\2\2\2\u014d\u014c\3\2\2\2\u014e"+
"\23\3\2\2\2\u014f\u0150\5\20\t\2\u0150\u0151\7<\2\2\u0151\u0152\5\u008c"+
"G\2\u0152\25\3\2\2\2\u0153\u0156\5\20\t\2\u0154\u0156\5\24\13\2\u0155"+
"\u0153\3\2\2\2\u0155\u0154\3\2\2\2\u0156\u015b\3\2\2\2\u0157\u0158\78"+
"\2\2\u0158\u015a\5\22\n\2\u0159\u0157\3\2\2\2\u015a\u015d\3\2\2\2\u015b"+
"\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015f\3\2\2\2\u015d\u015b\3\2"+
"\2\2\u015e\u0160\5\30\r\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2\u0160"+
"\27\3\2\2\2\u0161\u016c\78\2\2\u0162\u0167\5\32\16\2\u0163\u0164\78\2"+
"\2\u0164\u0166\5\22\n\2\u0165\u0163\3\2\2\2\u0166\u0169\3\2\2\2\u0167"+
"\u0165\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u016a\3\2\2\2\u0169\u0167\3\2"+
"\2\2\u016a\u016b\5\34\17\2\u016b\u016d\3\2\2\2\u016c\u0162\3\2\2\2\u016c"+
"\u016d\3\2\2\2\u016d\31\3\2\2\2\u016e\u0170\7\65\2\2\u016f\u0171\5\20"+
"\t\2\u0170\u016f\3\2\2\2\u0170\u0171\3\2\2\2\u0171\33\3\2\2\2\u0172\u0178"+
"\78\2\2\u0173\u0174\7;\2\2\u0174\u0176\5\20\t\2\u0175\u0177\78\2\2\u0176"+
"\u0175\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0179\3\2\2\2\u0178\u0173\3\2"+
"\2\2\u0178\u0179\3\2\2\2\u0179\u017b\3\2\2\2\u017a\u0172\3\2\2\2\u017a"+
"\u017b\3\2\2\2\u017b\u0182\3\2\2\2\u017c\u017d\7;\2\2\u017d\u017f\5\20"+
"\t\2\u017e\u0180\78\2\2\u017f\u017e\3\2\2\2\u017f\u0180\3\2\2\2\u0180"+
"\u0182\3\2\2\2\u0181\u017a\3\2\2\2\u0181\u017c\3\2\2\2\u0182\35\3\2\2"+
"\2\u0183\u0188\5\32\16\2\u0184\u0185\78\2\2\u0185\u0187\5\22\n\2\u0186"+
"\u0184\3\2\2\2\u0187\u018a\3\2\2\2\u0188\u0186\3\2\2\2\u0188\u0189\3\2"+
"\2\2\u0189\u018c\3\2\2\2\u018a\u0188\3\2\2\2\u018b\u018d\5 \21\2\u018c"+
"\u018b\3\2\2\2\u018c\u018d\3\2\2\2\u018d\37\3\2\2\2\u018e\u0194\78\2\2"+
"\u018f\u0190\7;\2\2\u0190\u0192\5\20\t\2\u0191\u0193\78\2\2\u0192\u0191"+
"\3\2\2\2\u0192\u0193\3\2\2\2\u0193\u0195\3\2\2\2\u0194\u018f\3\2\2\2\u0194"+
"\u0195\3\2\2\2\u0195!\3\2\2\2\u0196\u0197\7;\2\2\u0197\u0199\5\20\t\2"+
"\u0198\u019a\78\2\2\u0199\u0198\3\2\2\2\u0199\u019a\3\2\2\2\u019a#\3\2"+
"\2\2\u019b\u019f\5,\27\2\u019c\u019f\5\64\33\2\u019d\u019f\58\35\2\u019e"+
"\u019b\3\2\2\2\u019e\u019c\3\2\2\2\u019e\u019d\3\2\2\2\u019f%\3\2\2\2"+
"\u01a0\u01a1\7*\2\2\u01a1\'\3\2\2\2\u01a2\u01a5\5&\24\2\u01a3\u01a5\5"+
"*\26\2\u01a4\u01a2\3\2\2\2\u01a4\u01a3\3\2\2\2\u01a5)\3\2\2\2\u01a6\u01a7"+
"\5&\24\2\u01a7\u01a8\7<\2\2\u01a8\u01a9\5\u008cG\2\u01a9+\3\2\2\2\u01aa"+
"\u01ad\5&\24\2\u01ab\u01ad\5*\26\2\u01ac\u01aa\3\2\2\2\u01ac\u01ab\3\2"+
"\2\2\u01ad\u01b2\3\2\2\2\u01ae\u01af\78\2\2\u01af\u01b1\5(\25\2\u01b0"+
"\u01ae\3\2\2\2\u01b1\u01b4\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b2\u01b3\3\2"+
"\2\2\u01b3\u01b6\3\2\2\2\u01b4\u01b2\3\2\2\2\u01b5\u01b7\5.\30\2\u01b6"+
"\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7-\3\2\2\2\u01b8\u01c3\78\2\2\u01b9"+
"\u01be\5\60\31\2\u01ba\u01bb\78\2\2\u01bb\u01bd\5(\25\2\u01bc\u01ba\3"+
"\2\2\2\u01bd\u01c0\3\2\2\2\u01be\u01bc\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf"+
"\u01c1\3\2\2\2\u01c0\u01be\3\2\2\2\u01c1\u01c2\5\62\32\2\u01c2\u01c4\3"+
"\2\2\2\u01c3\u01b9\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4/\3\2\2\2\u01c5\u01c7"+
"\7\65\2\2\u01c6\u01c8\5&\24\2\u01c7\u01c6\3\2\2\2\u01c7\u01c8\3\2\2\2"+
"\u01c8\61\3\2\2\2\u01c9\u01cf\78\2\2\u01ca\u01cb\7;\2\2\u01cb\u01cd\5"+
"&\24\2\u01cc\u01ce\78\2\2\u01cd\u01cc\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce"+
"\u01d0\3\2\2\2\u01cf\u01ca\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d2\3\2"+
"\2\2\u01d1\u01c9\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d9\3\2\2\2\u01d3"+
"\u01d4\7;\2\2\u01d4\u01d6\5&\24\2\u01d5\u01d7\78\2\2\u01d6\u01d5\3\2\2"+
"\2\u01d6\u01d7\3\2\2\2\u01d7\u01d9\3\2\2\2\u01d8\u01d1\3\2\2\2\u01d8\u01d3"+
"\3\2\2\2\u01d9\63\3\2\2\2\u01da\u01df\5\60\31\2\u01db\u01dc\78\2\2\u01dc"+
"\u01de\5(\25\2\u01dd\u01db\3\2\2\2\u01de\u01e1\3\2\2\2\u01df\u01dd\3\2"+
"\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e3\3\2\2\2\u01e1\u01df\3\2\2\2\u01e2"+
"\u01e4\5\66\34\2\u01e3\u01e2\3\2\2\2\u01e3\u01e4\3\2\2\2\u01e4\65\3\2"+
"\2\2\u01e5\u01eb\78\2\2\u01e6\u01e7\7;\2\2\u01e7\u01e9\5&\24\2\u01e8\u01ea"+
"\78\2\2\u01e9\u01e8\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea\u01ec\3\2\2\2\u01eb"+
"\u01e6\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\67\3\2\2\2\u01ed\u01ee\7;\2\2"+
"\u01ee\u01f0\5&\24\2\u01ef\u01f1\78\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1"+
"\3\2\2\2\u01f19\3\2\2\2\u01f2\u01f5\5<\37\2\u01f3\u01f5\5x=\2\u01f4\u01f2"+
"\3\2\2\2\u01f4\u01f3\3\2\2\2\u01f5;\3\2\2\2\u01f6\u01fb\5> \2\u01f7\u01f8"+
"\7:\2\2\u01f8\u01fa\5> \2\u01f9\u01f7\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb"+
"\u01f9\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01ff\3\2\2\2\u01fd\u01fb\3\2"+
"\2\2\u01fe\u0200\7:\2\2\u01ff\u01fe\3\2\2\2\u01ff\u0200\3\2\2\2\u0200"+
"\u0201\3\2\2\2\u0201\u0202\7)\2\2\u0202=\3\2\2\2\u0203\u020c\5@!\2\u0204"+
"\u020c\5R*\2\u0205\u020c\5T+\2\u0206\u020c\5V,\2\u0207\u020c\5b\62\2\u0208"+
"\u020c\5r:\2\u0209\u020c\5t;\2\u020a\u020c\5v<\2\u020b\u0203\3\2\2\2\u020b"+
"\u0204\3\2\2\2\u020b\u0205\3\2\2\2\u020b\u0206\3\2\2\2\u020b\u0207\3\2"+
"\2\2\u020b\u0208\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020a\3\2\2\2\u020c"+
"?\3\2\2\2\u020d\u0211\5J&\2\u020e\u0211\5B\"\2\u020f\u0211\5D#\2\u0210"+
"\u020d\3\2\2\2\u0210\u020e\3\2\2\2\u0210\u020f\3\2\2\2\u0211A\3\2\2\2"+
"\u0212\u0219\5J&\2\u0213\u021a\5H%\2\u0214\u0217\5P)\2\u0215\u0218\5\u0100"+
"\u0081\2\u0216\u0218\5\u00ecw\2\u0217\u0215\3\2\2\2\u0217\u0216\3\2\2"+
"\2\u0218\u021a\3\2\2\2\u0219\u0213\3\2\2\2\u0219\u0214\3\2\2\2\u021aC"+
"\3\2\2\2\u021b\u021c\5J&\2\u021c\u021d\7<\2\2\u021d\u0222\5F$\2\u021e"+
"\u021f\7<\2\2\u021f\u0221\5F$\2\u0220\u021e\3\2\2\2\u0221\u0224\3\2\2"+
"\2\u0222\u0220\3\2\2\2\u0222\u0223\3\2\2\2\u0223E\3\2\2\2\u0224\u0222"+
"\3\2\2\2\u0225\u0228\5\u0100\u0081\2\u0226\u0228\5J&\2\u0227\u0225\3\2"+
"\2\2\u0227\u0226\3\2\2\2\u0228G\3\2\2\2\u0229\u022a\79\2\2\u022a\u022d"+
"\5\u008cG\2\u022b\u022c\7<\2\2\u022c\u022e\5\u008cG\2\u022d\u022b\3\2"+
"\2\2\u022d\u022e\3\2\2\2\u022eI\3\2\2\2\u022f\u0234\5L\'\2\u0230\u0231"+
"\78\2\2\u0231\u0233\5N(\2\u0232\u0230\3\2\2\2\u0233\u0236\3\2\2\2\u0234"+
"\u0232\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0238\3\2\2\2\u0236\u0234\3\2"+
"\2\2\u0237\u0239\78\2\2\u0238\u0237\3\2\2\2\u0238\u0239\3\2\2\2\u0239"+
"K\3\2\2\2\u023a\u023d\5\u008cG\2\u023b\u023d\5\u009eP\2\u023c\u023a\3"+
"\2\2\2\u023c\u023b\3\2\2\2\u023dM\3\2\2\2\u023e\u0241\5\u008cG\2\u023f"+
"\u0241\5\u009eP\2\u0240\u023e\3\2\2\2\u0240\u023f\3\2\2\2\u0241O\3\2\2"+
"\2\u0242\u0243\t\2\2\2\u0243Q\3\2\2\2\u0244\u0245\7#\2\2\u0245\u0246\5"+
"\u00e8u\2\u0246S\3\2\2\2\u0247\u0248\7$\2\2\u0248U\3\2\2\2\u0249\u024f"+
"\5X-\2\u024a\u024f\5Z.\2\u024b\u024f\5\\/\2\u024c\u024f\5`\61\2\u024d"+
"\u024f\5^\60\2\u024e\u0249\3\2\2\2\u024e\u024a\3\2\2\2\u024e\u024b\3\2"+
"\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2\2\2\u024fW\3\2\2\2\u0250\u0251"+
"\7&\2\2\u0251Y\3\2\2\2\u0252\u0253\7%\2\2\u0253[\3\2\2\2\u0254\u0256\7"+
"\7\2\2\u0255\u0257\5\u00ecw\2\u0256\u0255\3\2\2\2\u0256\u0257\3\2\2\2"+
"\u0257]\3\2\2\2\u0258\u0259\5\u0100\u0081\2\u0259_\3\2\2\2\u025a\u0260"+
"\7\b\2\2\u025b\u025e\5\u008cG\2\u025c\u025d\7\t\2\2\u025d\u025f\5\u008c"+
"G\2\u025e\u025c\3\2\2\2\u025e\u025f\3\2\2\2\u025f\u0261\3\2\2\2\u0260"+
"\u025b\3\2\2\2\u0260\u0261\3\2\2\2\u0261a\3\2\2\2\u0262\u0265\5d\63\2"+
"\u0263\u0265\5f\64\2\u0264\u0262\3\2\2\2\u0264\u0263\3\2\2\2\u0265c\3"+
"\2\2\2\u0266\u0267\7\n\2\2\u0267\u0268\5n8\2\u0268e\3\2\2\2\u0269\u0276"+
"\7\t\2\2\u026a\u026c\t\3\2\2\u026b\u026a\3\2\2\2\u026c\u026f\3\2\2\2\u026d"+
"\u026b\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u0270\3\2\2\2\u026f\u026d\3\2"+
"\2\2\u0270\u0277\5p9\2\u0271\u0273\t\3\2\2\u0272\u0271\3\2\2\2\u0273\u0274"+
"\3\2\2\2\u0274\u0272\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0277\3\2\2\2\u0276"+
"\u026d\3\2\2\2\u0276\u0272\3\2\2\2\u0277\u0278\3\2\2\2\u0278\u027f\7\n"+
"\2\2\u0279\u0280\7\65\2\2\u027a\u027b\7\66\2\2\u027b\u027c\5l\67\2\u027c"+
"\u027d\7\67\2\2\u027d\u0280\3\2\2\2\u027e\u0280\5l\67\2\u027f\u0279\3"+
"\2\2\2\u027f\u027a\3\2\2\2\u027f\u027e\3\2\2\2\u0280g\3\2\2\2\u0281\u0284"+
"\7*\2\2\u0282\u0283\7\13\2\2\u0283\u0285\7*\2\2\u0284\u0282\3\2\2\2\u0284"+
"\u0285\3\2\2\2\u0285i\3\2\2\2\u0286\u0289\5p9\2\u0287\u0288\7\13\2\2\u0288"+
"\u028a\7*\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028ak\3\2\2\2\u028b"+
"\u0290\5h\65\2\u028c\u028d\78\2\2\u028d\u028f\5h\65\2\u028e\u028c\3\2"+
"\2\2\u028f\u0292\3\2\2\2\u0290\u028e\3\2\2\2\u0290\u0291\3\2\2\2\u0291"+
"\u0294\3\2\2\2\u0292\u0290\3\2\2\2\u0293\u0295\78\2\2\u0294\u0293\3\2"+
"\2\2\u0294\u0295\3\2\2\2\u0295m\3\2\2\2\u0296\u029b\5j\66\2\u0297\u0298"+
"\78\2\2\u0298\u029a\5j\66\2\u0299\u0297\3\2\2\2\u029a\u029d\3\2\2\2\u029b"+
"\u0299\3\2\2\2\u029b\u029c\3\2\2\2\u029co\3\2\2\2\u029d\u029b\3\2\2\2"+
"\u029e\u02a3\7*\2\2\u029f\u02a0\7\63\2\2\u02a0\u02a2\7*\2\2\u02a1\u029f"+
"\3\2\2\2\u02a2\u02a5\3\2\2\2\u02a3\u02a1\3\2\2\2\u02a3\u02a4\3\2\2\2\u02a4"+
"q\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a6\u02a7\7\f\2\2\u02a7\u02ac\7*\2\2\u02a8"+
"\u02a9\78\2\2\u02a9\u02ab\7*\2\2\u02aa\u02a8\3\2\2\2\u02ab\u02ae\3\2\2"+
"\2\u02ac\u02aa\3\2\2\2\u02ac\u02ad\3\2\2\2\u02ads\3\2\2\2\u02ae\u02ac"+
"\3\2\2\2\u02af\u02b0\7\r\2\2\u02b0\u02b5\7*\2\2\u02b1\u02b2\78\2\2\u02b2"+
"\u02b4\7*\2\2\u02b3\u02b1\3\2\2\2\u02b4\u02b7\3\2\2\2\u02b5\u02b3\3\2"+
"\2\2\u02b5\u02b6\3\2\2\2\u02b6u\3\2\2\2\u02b7\u02b5\3\2\2\2\u02b8\u02b9"+
"\7\16\2\2\u02b9\u02bc\5\u008cG\2\u02ba\u02bb\78\2\2\u02bb\u02bd\5\u008c"+
"G\2\u02bc\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bdw\3\2\2\2\u02be\u02c7"+
"\5|?\2\u02bf\u02c7\5~@\2\u02c0\u02c7\5\u0080A\2\u02c1\u02c7\5\u0082B\2"+
"\u02c2\u02c7\5\u0084C\2\u02c3\u02c7\5\n\6\2\u02c4\u02c7\5\u00eex\2\u02c5"+
"\u02c7\5z>\2\u02c6\u02be\3\2\2\2\u02c6\u02bf\3\2\2\2\u02c6\u02c0\3\2\2"+
"\2\u02c6\u02c1\3\2\2\2\u02c6\u02c2\3\2\2\2\u02c6\u02c3\3\2\2\2\u02c6\u02c4"+
"\3\2\2\2\u02c6\u02c5\3\2\2\2\u02c7y\3\2\2\2\u02c8\u02cc\7\'\2\2\u02c9"+
"\u02cd\5\n\6\2\u02ca\u02cd\5\u0084C\2\u02cb\u02cd\5\u0080A\2\u02cc\u02c9"+
"\3\2\2\2\u02cc\u02ca\3\2\2\2\u02cc\u02cb\3\2\2\2\u02cd{\3\2\2\2\u02ce"+
"\u02cf\7\17\2\2\u02cf\u02d0\5\u008cG\2\u02d0\u02d1\79\2\2\u02d1\u02d9"+
"\5\u008aF\2\u02d2\u02d3\7\20\2\2\u02d3\u02d4\5\u008cG\2\u02d4\u02d5\7"+
"9\2\2\u02d5\u02d6\5\u008aF\2\u02d6\u02d8\3\2\2\2\u02d7\u02d2\3\2\2\2\u02d8"+
"\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02da\3\2\2\2\u02da\u02df\3\2"+
"\2\2\u02db\u02d9\3\2\2\2\u02dc\u02dd\7\21\2\2\u02dd\u02de\79\2\2\u02de"+
"\u02e0\5\u008aF\2\u02df\u02dc\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0}\3\2\2"+
"\2\u02e1\u02e2\7\22\2\2\u02e2\u02e3\5\u008cG\2\u02e3\u02e4\79\2\2\u02e4"+
"\u02e8\5\u008aF\2\u02e5\u02e6\7\21\2\2\u02e6\u02e7\79\2\2\u02e7\u02e9"+
"\5\u008aF\2\u02e8\u02e5\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\177\3\2\2\2"+
"\u02ea\u02eb\7\23\2\2\u02eb\u02ec\5\u00e8u\2\u02ec\u02ed\7\24\2\2\u02ed"+
"\u02ee\5\u00ecw\2\u02ee\u02ef\79\2\2\u02ef\u02f3\5\u008aF\2\u02f0\u02f1"+
"\7\21\2\2\u02f1\u02f2\79\2\2\u02f2\u02f4\5\u008aF\2\u02f3\u02f0\3\2\2"+
"\2\u02f3\u02f4\3\2\2\2\u02f4\u0081\3\2\2\2\u02f5\u02f6\7\25\2\2\u02f6"+
"\u02f7\79\2\2\u02f7\u030d\5\u008aF\2\u02f8\u02f9\5\u0088E\2\u02f9\u02fa"+
"\79\2\2\u02fa\u02fb\5\u008aF\2\u02fb\u02fd\3\2\2\2\u02fc\u02f8\3\2\2\2"+
"\u02fd\u02fe\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0303"+
"\3\2\2\2\u0300\u0301\7\21\2\2\u0301\u0302\79\2\2\u0302\u0304\5\u008aF"+
"\2\u0303\u0300\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0308\3\2\2\2\u0305\u0306"+
"\7\26\2\2\u0306\u0307\79\2\2\u0307\u0309\5\u008aF\2\u0308\u0305\3\2\2"+
"\2\u0308\u0309\3\2\2\2\u0309\u030e\3\2\2\2\u030a\u030b\7\26\2\2\u030b"+
"\u030c\79\2\2\u030c\u030e\5\u008aF\2\u030d\u02fc\3\2\2\2\u030d\u030a\3"+
"\2\2\2\u030e\u0083\3\2\2\2\u030f\u0310\7\27\2\2\u0310\u0315\5\u0086D\2"+
"\u0311\u0312\78\2\2\u0312\u0314\5\u0086D\2\u0313\u0311\3\2\2\2\u0314\u0317"+
"\3\2\2\2\u0315\u0313\3\2\2\2\u0315\u0316\3\2\2\2\u0316\u0318\3\2\2\2\u0317"+
"\u0315\3\2\2\2\u0318\u0319\79\2\2\u0319\u031a\5\u008aF\2\u031a\u0085\3"+
"\2\2\2\u031b\u031e\5\u008cG\2\u031c\u031d\7\13\2\2\u031d\u031f\5\u00a0"+
"Q\2\u031e\u031c\3\2\2\2\u031e\u031f\3\2\2\2\u031f\u0087\3\2\2\2\u0320"+
"\u0326\7\30\2\2\u0321\u0324\5\u008cG\2\u0322\u0323\7\13\2\2\u0323\u0325"+
"\7*\2\2\u0324\u0322\3\2\2\2\u0324\u0325\3\2\2\2\u0325\u0327\3\2\2\2\u0326"+
"\u0321\3\2\2\2\u0326\u0327\3\2\2\2\u0327\u0089\3\2\2\2\u0328\u0333\5<"+
"\37\2\u0329\u032a\7)\2\2\u032a\u032c\7d\2\2\u032b\u032d\5:\36\2\u032c"+
"\u032b\3\2\2\2\u032d\u032e\3\2\2\2\u032e\u032c\3\2\2\2\u032e\u032f\3\2"+
"\2\2\u032f\u0330\3\2\2\2\u0330\u0331\7e\2\2\u0331\u0333\3\2\2\2\u0332"+
"\u0328\3\2\2\2\u0332\u0329\3\2\2\2\u0333\u008b\3\2\2\2\u0334\u033a\5\u0094"+
"K\2\u0335\u0336\7\17\2\2\u0336\u0337\5\u0094K\2\u0337\u0338\7\21\2\2\u0338"+
"\u0339\5\u008cG\2\u0339\u033b\3\2\2\2\u033a\u0335\3\2\2\2\u033a\u033b"+
"\3\2\2\2\u033b\u033e\3\2\2\2\u033c\u033e\5\u0090I\2\u033d\u0334\3\2\2"+
"\2\u033d\u033c\3\2\2\2\u033e\u008d\3\2\2\2\u033f\u0342\5\u0094K\2\u0340"+
"\u0342\5\u0092J\2\u0341\u033f\3\2\2\2\u0341\u0340\3\2\2\2\u0342\u008f"+
"\3\2\2\2\u0343\u0345\7\31\2\2\u0344\u0346\5$\23\2\u0345\u0344\3\2\2\2"+
"\u0345\u0346\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348\79\2\2\u0348\u0349"+
"\5\u008cG\2\u0349\u0091\3\2\2\2\u034a\u034c\7\31\2\2\u034b\u034d\5$\23"+
"\2\u034c\u034b\3\2\2\2\u034c\u034d\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u034f"+
"\79\2\2\u034f\u0350\5\u008eH\2\u0350\u0093\3\2\2\2\u0351\u0356\5\u0096"+
"L\2\u0352\u0353\7\32\2\2\u0353\u0355\5\u0096L\2\u0354\u0352\3\2\2\2\u0355"+
"\u0358\3\2\2\2\u0356\u0354\3\2\2\2\u0356\u0357\3\2\2\2\u0357\u0095\3\2"+
"\2\2\u0358\u0356\3\2\2\2\u0359\u035e\5\u0098M\2\u035a\u035b\7\33\2\2\u035b"+
"\u035d\5\u0098M\2\u035c\u035a\3\2\2\2\u035d\u0360\3\2\2\2\u035e\u035c"+
"\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0097\3\2\2\2\u0360\u035e\3\2\2\2\u0361"+
"\u0362\7\34\2\2\u0362\u0365\5\u0098M\2\u0363\u0365\5\u009aN\2\u0364\u0361"+
"\3\2\2\2\u0364\u0363\3\2\2\2\u0365\u0099\3\2\2\2\u0366\u036c\5\u00a0Q"+
"\2\u0367\u0368\5\u009cO\2\u0368\u0369\5\u00a0Q\2\u0369\u036b\3\2\2\2\u036a"+
"\u0367\3\2\2\2\u036b\u036e\3\2\2\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2"+
"\2\2\u036d\u009b\3\2\2\2\u036e\u036c\3\2\2\2\u036f\u037d\7L\2\2\u0370"+
"\u037d\7M\2\2\u0371\u037d\7N\2\2\u0372\u037d\7O\2\2\u0373\u037d\7P\2\2"+
"\u0374\u037d\7Q\2\2\u0375\u037d\7R\2\2\u0376\u037d\7\24\2\2\u0377\u0378"+
"\7\34\2\2\u0378\u037d\7\24\2\2\u0379\u037d\7\35\2\2\u037a\u037b\7\35\2"+
"\2\u037b\u037d\7\34\2\2\u037c\u036f\3\2\2\2\u037c\u0370\3\2\2\2\u037c"+
"\u0371\3\2\2\2\u037c\u0372\3\2\2\2\u037c\u0373\3\2\2\2\u037c\u0374\3\2"+
"\2\2\u037c\u0375\3\2\2\2\u037c\u0376\3\2\2\2\u037c\u0377\3\2\2\2\u037c"+
"\u0379\3\2\2\2\u037c\u037a\3\2\2\2\u037d\u009d\3\2\2\2\u037e\u037f\7\65"+
"\2\2\u037f\u0380\5\u00a0Q\2\u0380\u009f\3\2\2\2\u0381\u0386\5\u00a2R\2"+
"\u0382\u0383\7?\2\2\u0383\u0385\5\u00a2R\2\u0384\u0382\3\2\2\2\u0385\u0388"+
"\3\2\2\2\u0386\u0384\3\2\2\2\u0386\u0387\3\2\2\2\u0387\u00a1\3\2\2\2\u0388"+
"\u0386\3\2\2\2\u0389\u038e\5\u00a4S\2\u038a\u038b\7@\2\2\u038b\u038d\5"+
"\u00a4S\2\u038c\u038a\3\2\2\2\u038d\u0390\3\2\2\2\u038e\u038c\3\2\2\2"+
"\u038e\u038f\3\2\2\2\u038f\u00a3\3\2\2\2\u0390\u038e\3\2\2\2\u0391\u0396"+
"\5\u00a6T\2\u0392\u0393\7A\2\2\u0393\u0395\5\u00a6T\2\u0394\u0392\3\2"+
"\2\2\u0395\u0398\3\2\2\2\u0396\u0394\3\2\2\2\u0396\u0397\3\2\2\2\u0397"+
"\u00a5\3\2\2\2\u0398\u0396\3\2\2\2\u0399\u039f\5\u00aaV\2\u039a\u039b"+
"\5\u00a8U\2\u039b\u039c\5\u00aaV\2\u039c\u039e\3\2\2\2\u039d\u039a\3\2"+
"\2\2\u039e\u03a1\3\2\2\2\u039f\u039d\3\2\2\2\u039f\u03a0\3\2\2\2\u03a0"+
"\u00a7\3\2\2\2\u03a1\u039f\3\2\2\2\u03a2\u03a3\t\4\2\2\u03a3\u00a9\3\2"+
"\2\2\u03a4\u03aa\5\u00aeX\2\u03a5\u03a6\5\u00acW\2\u03a6\u03a7\5\u00ae"+
"X\2\u03a7\u03a9\3\2\2\2\u03a8\u03a5\3\2\2\2\u03a9\u03ac\3\2\2\2\u03aa"+
"\u03a8\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u00ab\3\2\2\2\u03ac\u03aa\3\2"+
"\2\2\u03ad\u03ae\t\5\2\2\u03ae\u00ad\3\2\2\2\u03af\u03b5\5\u00b2Z\2\u03b0"+
"\u03b1\5\u00b0Y\2\u03b1\u03b2\5\u00b2Z\2\u03b2\u03b4\3\2\2\2\u03b3\u03b0"+
"\3\2\2\2\u03b4\u03b7\3\2\2\2\u03b5\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6"+
"\u00af\3\2\2\2\u03b7\u03b5\3\2\2\2\u03b8\u03b9\t\6\2\2\u03b9\u00b1\3\2"+
"\2\2\u03ba\u03bb\5\u00b4[\2\u03bb\u03bc\5\u00b2Z\2\u03bc\u03bf\3\2\2\2"+
"\u03bd\u03bf\5\u00b6\\\2\u03be\u03ba\3\2\2\2\u03be\u03bd\3\2\2\2\u03bf"+
"\u00b3\3\2\2\2\u03c0\u03c1\t\7\2\2\u03c1\u00b5\3\2\2\2\u03c2\u03c5\5\u00b8"+
"]\2\u03c3\u03c4\7;\2\2\u03c4\u03c6\5\u00b2Z\2\u03c5\u03c3\3\2\2\2\u03c5"+
"\u03c6\3\2\2\2\u03c6\u00b7\3\2\2\2\u03c7\u03c9\7(\2\2\u03c8\u03c7\3\2"+
"\2\2\u03c8\u03c9\3\2\2\2\u03c9\u03ca\3\2\2\2\u03ca\u03cb\5\u00ba^\2\u03cb"+
"\u00b9\3\2\2\2\u03cc\u03cd\7\66\2\2\u03cd\u03ce\5\u008cG\2\u03ce\u03cf"+
"\7\67\2\2\u03cf\u03d8\3\2\2\2\u03d0\u03d4\5\u00bc_\2\u03d1\u03d3\5\u00be"+
"`\2\u03d2\u03d1\3\2\2\2\u03d3\u03d6\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d4"+
"\u03d5\3\2\2\2\u03d5\u03d8\3\2\2\2\u03d6\u03d4\3\2\2\2\u03d7\u03cc\3\2"+
"\2\2\u03d7\u03d0\3\2\2\2\u03d8\u00bb\3\2\2\2\u03d9\u03e8\5\u00c6d\2\u03da"+
"\u03e8\5\u00caf\2\u03db\u03e8\5\u00ceh\2\u03dc\u03e8\7*\2\2\u03dd\u03e8"+
"\7\4\2\2\u03de\u03e0\7\3\2\2\u03df\u03de\3\2\2\2\u03e0\u03e1\3\2\2\2\u03e1"+
"\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e8\3\2\2\2\u03e3\u03e8\7\64"+
"\2\2\u03e4\u03e8\7\36\2\2\u03e5\u03e8\7\37\2\2\u03e6\u03e8\7 \2\2\u03e7"+
"\u03d9\3\2\2\2\u03e7\u03da\3\2\2\2\u03e7\u03db\3\2\2\2\u03e7\u03dc\3\2"+
"\2\2\u03e7\u03dd\3\2\2\2\u03e7\u03df\3\2\2\2\u03e7\u03e3\3\2\2\2\u03e7"+
"\u03e4\3\2\2\2\u03e7\u03e5\3\2\2\2\u03e7\u03e6\3\2\2\2\u03e8\u00bd\3\2"+
"\2\2\u03e9\u03ed\5\u00c0a\2\u03ea\u03ed\5\u00c2b\2\u03eb\u03ed\5\u00c4"+
"c\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+
"\u00bf\3\2\2\2\u03ee\u03f0\7\66\2\2\u03ef\u03f1\5\u00f0y\2\u03f0\u03ef"+
"\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f3\7\67\2\2"+
"\u03f3\u00c1\3\2\2\2\u03f4\u03f5\7=\2\2\u03f5\u03f6\5\u00dan\2\u03f6\u03f7"+
"\7>\2\2\u03f7\u00c3\3\2\2\2\u03f8\u03f9\7\63\2\2\u03f9\u03fa\7*\2\2\u03fa"+
"\u00c5\3\2\2\2\u03fb\u03fd\7\66\2\2\u03fc\u03fe\5\u00c8e\2\u03fd\u03fc"+
"\3\2\2\2\u03fd\u03fe\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\u0400\7\67\2\2"+
"\u0400\u00c7\3\2\2\2\u0401\u0416\5\u0100\u0081\2\u0402\u0413\5L\'\2\u0403"+
"\u0405\5\u00fc\177\2\u0404\u0403\3\2\2\2\u0405\u0408\3\2\2\2\u0406\u0404"+
"\3\2\2\2\u0406\u0407\3\2\2\2\u0407\u0414\3\2\2\2\u0408\u0406\3\2\2\2\u0409"+
"\u040a\78\2\2\u040a\u040c\5N(\2\u040b\u0409\3\2\2\2\u040c\u040f\3\2\2"+
"\2\u040d\u040b\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0411\3\2\2\2\u040f\u040d"+
"\3\2\2\2\u0410\u0412\78\2\2\u0411\u0410\3\2\2\2\u0411\u0412\3\2\2\2\u0412"+
"\u0414\3\2\2\2\u0413\u0406\3\2\2\2\u0413\u040d\3\2\2\2\u0414\u0416\3\2"+
"\2\2\u0415\u0401\3\2\2\2\u0415\u0402\3\2\2\2\u0416\u00c9\3\2\2\2\u0417"+
"\u0419\7=\2\2\u0418\u041a\5\u00ccg\2\u0419\u0418\3\2\2\2\u0419\u041a\3"+
"\2\2\2\u041a\u041b\3\2\2\2\u041b\u041c\7>\2\2\u041c\u00cb\3\2\2\2\u041d"+
"\u042e\5L\'\2\u041e\u0420\5\u00fc\177\2\u041f\u041e\3\2\2\2\u0420\u0423"+
"\3\2\2\2\u0421\u041f\3\2\2\2\u0421\u0422\3\2\2\2\u0422\u042f\3\2\2\2\u0423"+
"\u0421\3\2\2\2\u0424\u0425\78\2\2\u0425\u0427\5N(\2\u0426\u0424\3\2\2"+
"\2\u0427\u042a\3\2\2\2\u0428\u0426\3\2\2\2\u0428\u0429\3\2\2\2\u0429\u042c"+
"\3\2\2\2\u042a\u0428\3\2\2\2\u042b\u042d\78\2\2\u042c\u042b\3\2\2\2\u042c"+
"\u042d\3\2\2\2\u042d\u042f\3\2\2\2\u042e\u0421\3\2\2\2\u042e\u0428\3\2"+
"\2\2\u042f\u00cd\3\2\2\2\u0430\u0432\7J\2\2\u0431\u0433\5\u00d0i\2\u0432"+
"\u0431\3\2\2\2\u0432\u0433\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0435\7K"+
"\2\2\u0435\u00cf\3\2\2\2\u0436\u0447\5\u00d2j\2\u0437\u0439\5\u00fc\177"+
"\2\u0438\u0437\3\2\2\2\u0439\u043c\3\2\2\2\u043a\u0438\3\2\2\2\u043a\u043b"+
"\3\2\2\2\u043b\u0448\3\2\2\2\u043c\u043a\3\2\2\2\u043d\u043e\78\2\2\u043e"+
"\u0440\5\u00d4k\2\u043f\u043d\3\2\2\2\u0440\u0443\3\2\2\2\u0441\u043f"+
"\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0444"+
"\u0446\78\2\2\u0445\u0444\3\2\2\2\u0445\u0446\3\2\2\2\u0446\u0448\3\2"+
"\2\2\u0447\u043a\3\2\2\2\u0447\u0441\3\2\2\2\u0448\u045d\3\2\2\2\u0449"+
"\u045a\5\u00d6l\2\u044a\u044c\5\u00fc\177\2\u044b\u044a\3\2\2\2\u044c"+
"\u044f\3\2\2\2\u044d\u044b\3\2\2\2\u044d\u044e\3\2\2\2\u044e\u045b\3\2"+
"\2\2\u044f\u044d\3\2\2\2\u0450\u0451\78\2\2\u0451\u0453\5\u00d8m\2\u0452"+
"\u0450\3\2\2\2\u0453\u0456\3\2\2\2\u0454\u0452\3\2\2\2\u0454\u0455\3\2"+
"\2\2\u0455\u0458\3\2\2\2\u0456\u0454\3\2\2\2\u0457\u0459\78\2\2\u0458"+
"\u0457\3\2\2\2\u0458\u0459\3\2\2\2\u0459\u045b\3\2\2\2\u045a\u044d\3\2"+
"\2\2\u045a\u0454\3\2\2\2\u045b\u045d\3\2\2\2\u045c\u0436\3\2\2\2\u045c"+
"\u0449\3\2\2\2\u045d\u00d1\3\2\2\2\u045e\u045f\5\u008cG\2\u045f\u0460"+
"\79\2\2\u0460\u0461\5\u008cG\2\u0461\u0465\3\2\2\2\u0462\u0463\7;\2\2"+
"\u0463\u0465\5\u00a0Q\2\u0464\u045e\3\2\2\2\u0464\u0462\3\2\2\2\u0465"+
"\u00d3\3\2\2\2\u0466\u0467\5\u008cG\2\u0467\u0468\79\2\2\u0468\u0469\5"+
"\u008cG\2\u0469\u046d\3\2\2\2\u046a\u046b\7;\2\2\u046b\u046d\5\u00a0Q"+
"\2\u046c\u0466\3\2\2\2\u046c\u046a\3\2\2\2\u046d\u00d5\3\2\2\2\u046e\u0471"+
"\5\u008cG\2\u046f\u0471\5\u009eP\2\u0470\u046e\3\2\2\2\u0470\u046f\3\2"+
"\2\2\u0471\u00d7\3\2\2\2\u0472\u0475\5\u008cG\2\u0473\u0475\5\u009eP\2"+
"\u0474\u0472\3\2\2\2\u0474\u0473\3\2\2\2\u0475\u00d9\3\2\2\2\u0476\u047b"+
"\5\u00dco\2\u0477\u0478\78\2\2\u0478\u047a\5\u00dco\2\u0479\u0477\3\2"+
"\2\2\u047a\u047d\3\2\2\2\u047b\u0479\3\2\2\2\u047b\u047c\3\2\2\2\u047c"+
"\u047f\3\2\2\2\u047d\u047b\3\2\2\2\u047e\u0480\78\2\2\u047f\u047e\3\2"+
"\2\2\u047f\u0480\3\2\2\2\u0480\u00db\3\2\2\2\u0481\u0484\5\u00dep\2\u0482"+
"\u0484\5\u00e0q\2\u0483\u0481\3\2\2\2\u0483\u0482\3\2\2\2\u0484\u00dd"+
"\3\2\2\2\u0485\u0486\5\u008cG\2\u0486\u00df\3\2\2\2\u0487\u0488\5\u00e2"+
"r\2\u0488\u0489\79\2\2\u0489\u048b\5\u00e4s\2\u048a\u048c\5\u00e6t\2\u048b"+
"\u048a\3\2\2\2\u048b\u048c\3\2\2\2\u048c\u00e1\3\2\2\2\u048d\u048f\5\u008c"+
"G\2\u048e\u048d\3\2\2\2\u048e\u048f\3\2\2\2\u048f\u00e3\3\2\2\2\u0490"+
"\u0492\5\u008cG\2\u0491\u0490\3\2\2\2\u0491\u0492\3\2\2\2\u0492\u00e5"+
"\3\2\2\2\u0493\u0495\79\2\2\u0494\u0496\5\u008cG\2\u0495\u0494\3\2\2\2"+
"\u0495\u0496\3\2\2\2\u0496\u00e7\3\2\2\2\u0497\u049c\5\u00eav\2\u0498"+
"\u0499\78\2\2\u0499\u049b\5\u00eav\2\u049a\u0498\3\2\2\2\u049b\u049e\3"+
"\2\2\2\u049c\u049a\3\2\2\2\u049c\u049d\3\2\2\2\u049d\u04a0\3\2\2\2\u049e"+
"\u049c\3\2\2\2\u049f\u04a1\78\2\2\u04a0\u049f\3\2\2\2\u04a0\u04a1\3\2"+
"\2\2\u04a1\u00e9\3\2\2\2\u04a2\u04a5\5\u00a0Q\2\u04a3\u04a5\5\u009eP\2"+
"\u04a4\u04a2\3\2\2\2\u04a4\u04a3\3\2\2\2\u04a5\u00eb\3\2\2\2\u04a6\u04ab"+
"\5\u008cG\2\u04a7\u04a8\78\2\2\u04a8\u04aa\5\u008cG\2\u04a9\u04a7\3\2"+
"\2\2\u04aa\u04ad\3\2\2\2\u04ab\u04a9\3\2\2\2\u04ab\u04ac\3\2\2\2\u04ac"+
"\u04af\3\2\2\2\u04ad\u04ab\3\2\2\2\u04ae\u04b0\78\2\2\u04af\u04ae\3\2"+
"\2\2\u04af\u04b0\3\2\2\2\u04b0\u00ed\3\2\2\2\u04b1\u04b3\5\b\5\2\u04b2"+
"\u04b1\3\2\2\2\u04b3\u04b6\3\2\2\2\u04b4\u04b2\3\2\2\2\u04b4\u04b5\3\2"+
"\2\2\u04b5\u04b7\3\2\2\2\u04b6\u04b4\3\2\2\2\u04b7\u04b8\7!\2\2\u04b8"+
"\u04be\7*\2\2\u04b9\u04bb\7\66\2\2\u04ba\u04bc\5\u00f0y\2\u04bb\u04ba"+
"\3\2\2\2\u04bb\u04bc\3\2\2\2\u04bc\u04bd\3\2\2\2\u04bd\u04bf\7\67\2\2"+
"\u04be\u04b9\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c1"+
"\79\2\2\u04c1\u04c2\5\u008aF\2\u04c2\u00ef\3\2\2\2\u04c3\u04c8\5\u00f2"+
"z\2\u04c4\u04c5\78\2\2\u04c5\u04c7\5\u00f2z\2\u04c6\u04c4\3\2\2\2\u04c7"+
"\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2\2\2\u04c9\u04cc\3\2"+
"\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cd\78\2\2\u04cc\u04cb\3\2\2\2\u04cc"+
"\u04cd\3\2\2\2\u04cd\u00f1\3\2\2\2\u04ce\u04d3\5\u00f4{\2\u04cf\u04d3"+
"\5\u00f6|\2\u04d0\u04d3\5\u00f8}\2\u04d1\u04d3\5\u00fa~\2\u04d2\u04ce"+
"\3\2\2\2\u04d2\u04cf\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2\u04d1\3\2\2\2\u04d3"+
"\u00f3\3\2\2\2\u04d4\u04d8\5\u008cG\2\u04d5\u04d7\5\u00fc\177\2\u04d6"+
"\u04d5\3\2\2\2\u04d7\u04da\3\2\2\2\u04d8\u04d6\3\2\2\2\u04d8\u04d9\3\2"+
"\2\2\u04d9\u00f5\3\2\2\2\u04da\u04d8\3\2\2\2\u04db\u04dc\5\u008cG\2\u04dc"+
"\u04dd\7<\2\2\u04dd\u04de\5\u008cG\2\u04de\u00f7\3\2\2\2\u04df\u04e0\7"+
"\65\2\2\u04e0\u04e1\5\u008cG\2\u04e1\u00f9\3\2\2\2\u04e2\u04e3\7;\2\2"+
"\u04e3\u04e4\5\u008cG\2\u04e4\u00fb\3\2\2\2\u04e5\u04e7\7\'\2\2\u04e6"+
"\u04e5\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7\u04e8\3\2\2\2\u04e8\u04e9\7\23"+
"\2\2\u04e9\u04ea\5\u00e8u\2\u04ea\u04eb\7\24\2\2\u04eb\u04ef\5\u0094K"+
"\2\u04ec\u04ee\5\u00fe\u0080\2\u04ed\u04ec\3\2\2\2\u04ee\u04f1\3\2\2\2"+
"\u04ef\u04ed\3\2\2\2\u04ef\u04f0\3\2\2\2\u04f0\u00fd\3\2\2\2\u04f1\u04ef"+
"\3\2\2\2\u04f2\u04f3\7\17\2\2\u04f3\u04f4\5\u008eH\2\u04f4\u00ff\3\2\2"+
"\2\u04f5\u04f7\7\"\2\2\u04f6\u04f8\5\u0102\u0082\2\u04f7\u04f6\3\2\2\2"+
"\u04f7\u04f8\3\2\2\2\u04f8\u0101\3\2\2\2\u04f9\u04fa\7\t\2\2\u04fa\u04fd"+
"\5\u008cG\2\u04fb\u04fd\5\u00ecw\2\u04fc\u04f9\3\2\2\2\u04fc\u04fb\3\2"+
"\2\2\u04fd\u0103\3\2\2\2\u00aa\u0109\u010d\u010f\u0118\u0121\u0124\u012b"+
"\u012f\u0136\u013d\u0144\u0149\u014d\u0155\u015b\u015f\u0167\u016c\u0170"+
"\u0176\u0178\u017a\u017f\u0181\u0188\u018c\u0192\u0194\u0199\u019e\u01a4"+
"\u01ac\u01b2\u01b6\u01be\u01c3\u01c7\u01cd\u01cf\u01d1\u01d6\u01d8\u01df"+
"\u01e3\u01e9\u01eb\u01f0\u01f4\u01fb\u01ff\u020b\u0210\u0217\u0219\u0222"+
"\u0227\u022d\u0234\u0238\u023c\u0240\u024e\u0256\u025e\u0260\u0264\u026d"+
"\u0274\u0276\u027f\u0284\u0289\u0290\u0294\u029b\u02a3\u02ac\u02b5\u02bc"+
"\u02c6\u02cc\u02d9\u02df\u02e8\u02f3\u02fe\u0303\u0308\u030d\u0315\u031e"+
"\u0324\u0326\u032e\u0332\u033a\u033d\u0341\u0345\u034c\u0356\u035e\u0364"+
"\u036c\u037c\u0386\u038e\u0396\u039f\u03aa\u03b5\u03be\u03c5\u03c8\u03d4"+
"\u03d7\u03e1\u03e7\u03ec\u03f0\u03fd\u0406\u040d\u0411\u0413\u0415\u0419"+
"\u0421\u0428\u042c\u042e\u0432\u043a\u0441\u0445\u0447\u044d\u0454\u0458"+
"\u045a\u045c\u0464\u046c\u0470\u0474\u047b\u047f\u0483\u048b\u048e\u0491"+
"\u0495\u049c\u04a0\u04a4\u04ab\u04af\u04b4\u04bb\u04be\u04c8\u04cc\u04d2"+
"\u04d8\u04e6\u04ef\u04f7\u04fc";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy