# Generated from PythonParser.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

if __name__ is not None and "." in __name__:
    from .PythonParserBase import PythonParserBase
else:
    from PythonParserBase import PythonParserBase


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3f")
        buf.write("\u03cc\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\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")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\3\2\3\2\3\2\5\2|\n\2\3\2\3\2\3\3\3\3\3\3\3\3\3")
        buf.write("\3\5\3\u0085\n\3\3\4\3\4\6\4\u0089\n\4\r\4\16\4\u008a")
        buf.write("\3\5\3\5\7\5\u008f\n\5\f\5\16\5\u0092\13\5\3\6\3\6\5\6")
        buf.write("\u0096\n\6\3\7\3\7\3\7\3\7\3\7\7\7\u009d\n\7\f\7\16\7")
        buf.write("\u00a0\13\7\3\7\5\7\u00a3\n\7\3\7\3\7\3\7\3\7\3\7\5\7")
        buf.write("\u00aa\n\7\3\7\5\7\u00ad\n\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\5\7\u00b6\n\7\3\7\3\7\3\7\3\7\6\7\u00bc\n\7\r\7\16")
        buf.write("\7\u00bd\3\7\5\7\u00c1\n\7\3\7\5\7\u00c4\n\7\3\7\5\7\u00c7")
        buf.write("\n\7\3\7\5\7\u00ca\n\7\3\7\3\7\3\7\3\7\7\7\u00d0\n\7\f")
        buf.write("\7\16\7\u00d3\13\7\3\7\3\7\3\7\3\7\7\7\u00d9\n\7\f\7\16")
        buf.write("\7\u00dc\13\7\3\7\3\7\5\7\u00e0\n\7\5\7\u00e2\n\7\3\b")
        buf.write("\3\b\3\b\3\b\6\b\u00e8\n\b\r\b\16\b\u00e9\3\b\3\b\5\b")
        buf.write("\u00ee\n\b\3\t\3\t\3\t\3\t\5\t\u00f4\n\t\3\t\5\t\u00f7")
        buf.write("\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3")
        buf.write("\f\3\f\3\f\3\f\3\r\3\r\3\r\5\r\u010b\n\r\3\16\3\16\3\16")
        buf.write("\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0119")
        buf.write("\n\16\5\16\u011b\n\16\3\16\3\16\3\16\3\17\3\17\3\17\3")
        buf.write("\17\5\17\u0124\n\17\3\17\5\17\u0127\n\17\3\17\3\17\3\17")
        buf.write("\3\20\5\20\u012d\n\20\3\20\3\20\3\20\3\20\5\20\u0133\n")
        buf.write("\20\3\20\3\20\3\20\5\20\u0138\n\20\3\20\3\20\3\20\3\21")
        buf.write("\3\21\3\21\5\21\u0140\n\21\3\21\3\21\3\21\5\21\u0145\n")
        buf.write("\21\3\21\3\21\5\21\u0149\n\21\3\21\5\21\u014c\n\21\3\21")
        buf.write("\5\21\u014f\n\21\3\21\3\21\5\21\u0153\n\21\5\21\u0155")
        buf.write("\n\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\7\24")
        buf.write("\u0160\n\24\f\24\16\24\u0163\13\24\3\25\3\25\3\25\5\25")
        buf.write("\u0168\n\25\3\25\5\25\u016b\n\25\3\26\3\26\3\26\5\26\u0170")
        buf.write("\n\26\3\27\3\27\3\27\7\27\u0175\n\27\f\27\16\27\u0178")
        buf.write("\13\27\3\27\5\27\u017b\n\27\3\27\3\27\3\30\3\30\5\30\u0181")
        buf.write("\n\30\3\30\3\30\3\30\3\30\3\30\7\30\u0188\n\30\f\30\16")
        buf.write("\30\u018b\13\30\3\30\5\30\u018e\n\30\3\30\3\30\3\30\3")
        buf.write("\30\6\30\u0194\n\30\r\30\16\30\u0195\3\30\5\30\u0199\n")
        buf.write("\30\5\30\u019b\n\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
        buf.write("\3\30\3\30\5\30\u01a6\n\30\3\30\3\30\3\30\3\30\3\30\3")
        buf.write("\30\5\30\u01ae\n\30\5\30\u01b0\n\30\5\30\u01b2\n\30\3")
        buf.write("\30\3\30\5\30\u01b6\n\30\3\30\3\30\3\30\3\30\3\30\7\30")
        buf.write("\u01bd\n\30\f\30\16\30\u01c0\13\30\3\30\3\30\6\30\u01c4")
        buf.write("\n\30\r\30\16\30\u01c5\5\30\u01c8\n\30\3\30\3\30\3\30")
        buf.write("\3\30\3\30\3\30\3\30\5\30\u01d1\n\30\3\30\3\30\3\30\3")
        buf.write("\30\7\30\u01d7\n\30\f\30\16\30\u01da\13\30\3\30\3\30\3")
        buf.write("\30\3\30\3\30\3\30\3\30\5\30\u01e3\n\30\5\30\u01e5\n\30")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u01ed\n\30\3\30\3")
        buf.write("\30\3\30\3\30\3\30\7\30\u01f4\n\30\f\30\16\30\u01f7\13")
        buf.write("\30\3\30\3\30\5\30\u01fb\n\30\3\31\3\31\5\31\u01ff\n\31")
        buf.write("\3\31\3\31\6\31\u0203\n\31\r\31\16\31\u0204\3\31\3\31")
        buf.write("\5\31\u0209\n\31\3\31\5\31\u020c\n\31\3\32\3\32\3\32\3")
        buf.write("\33\3\33\3\33\3\33\7\33\u0215\n\33\f\33\16\33\u0218\13")
        buf.write("\33\3\33\3\33\5\33\u021c\n\33\3\33\5\33\u021f\n\33\3\33")
        buf.write("\3\33\3\33\3\33\3\33\5\33\u0226\n\33\3\33\3\33\3\33\3")
        buf.write("\33\3\33\5\33\u022d\n\33\5\33\u022f\n\33\3\34\3\34\3\34")
        buf.write("\7\34\u0234\n\34\f\34\16\34\u0237\13\34\3\34\5\34\u023a")
        buf.write("\n\34\3\35\3\35\3\35\7\35\u023f\n\35\f\35\16\35\u0242")
        buf.write("\13\35\3\35\5\35\u0245\n\35\3\36\3\36\3\36\5\36\u024a")
        buf.write("\n\36\3\37\3\37\3\37\7\37\u024f\n\37\f\37\16\37\u0252")
        buf.write("\13\37\3 \3 \3 \5 \u0257\n \3!\3!\3!\3!\3!\3!\5!\u025f")
        buf.write("\n!\3!\3!\5!\u0263\n!\3!\3!\5!\u0267\n!\3\"\3\"\3\"\5")
        buf.write("\"\u026c\n\"\3\"\3\"\3\"\5\"\u0271\n\"\3\"\3\"\5\"\u0275")
        buf.write("\n\"\3\"\5\"\u0278\n\"\3\"\5\"\u027b\n\"\3\"\3\"\5\"\u027f")
        buf.write("\n\"\5\"\u0281\n\"\3#\3#\3#\7#\u0286\n#\f#\16#\u0289\13")
        buf.write("#\3$\3$\3$\5$\u028e\n$\3$\5$\u0291\n$\3%\3%\3%\3&\3&\3")
        buf.write("&\3\'\3\'\3\'\3\'\5\'\u029d\n\'\3\'\3\'\3\'\3\'\3\'\3")
        buf.write("\'\7\'\u02a5\n\'\f\'\16\'\u02a8\13\'\3(\3(\3(\3(\3(\3")
        buf.write("(\3(\3(\3(\3(\3(\3(\5(\u02b6\n(\3(\3(\3(\5(\u02bb\n(\5")
        buf.write("(\u02bd\n(\3(\7(\u02c0\n(\f(\16(\u02c3\13(\3)\3)\5)\u02c7")
        buf.write("\n)\3)\3)\7)\u02cb\n)\f)\16)\u02ce\13)\3)\3)\5)\u02d2")
        buf.write("\n)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3")
        buf.write(")\3)\3)\3)\3)\7)\u02e9\n)\f)\16)\u02ec\13)\3*\3*\3*\5")
        buf.write("*\u02f1\n*\3*\3*\3*\5*\u02f6\n*\3*\3*\3*\5*\u02fb\n*\3")
        buf.write("*\3*\3*\3*\5*\u0301\n*\3*\3*\3*\3*\3*\3*\3*\5*\u030a\n")
        buf.write("*\3*\3*\3*\6*\u030f\n*\r*\16*\u0310\5*\u0313\n*\3+\3+")
        buf.write("\3+\3+\3+\3+\5+\u031b\n+\3+\3+\3+\3+\3+\3+\3+\5+\u0324")
        buf.write("\n+\7+\u0326\n+\f+\16+\u0329\13+\3+\5+\u032c\n+\3+\3+")
        buf.write("\3+\3+\3+\3+\5+\u0334\n+\3,\3,\5,\u0338\n,\3,\3,\3,\3")
        buf.write(",\5,\u033e\n,\7,\u0340\n,\f,\16,\u0343\13,\3,\5,\u0346")
        buf.write("\n,\5,\u0348\n,\3-\3-\3-\7-\u034d\n-\f-\16-\u0350\13-")
        buf.write("\3-\5-\u0353\n-\3.\3.\3.\3.\3.\3.\7.\u035b\n.\f.\16.\u035e")
        buf.write("\13.\3/\3/\3\60\3\60\3\60\5\60\u0365\n\60\3\61\3\61\3")
        buf.write("\62\3\62\5\62\u036b\n\62\3\63\3\63\3\63\5\63\u0370\n\63")
        buf.write("\3\64\3\64\3\64\5\64\u0375\n\64\3\64\5\64\u0378\n\64\3")
        buf.write("\65\3\65\5\65\u037c\n\65\3\65\3\65\3\65\3\65\3\65\5\65")
        buf.write("\u0383\n\65\3\66\3\66\3\66\7\66\u0388\n\66\f\66\16\66")
        buf.write("\u038b\13\66\3\66\5\66\u038e\n\66\3\67\3\67\3\67\3\67")
        buf.write("\5\67\u0394\n\67\3\67\3\67\5\67\u0398\n\67\38\38\38\7")
        buf.write("8\u039d\n8\f8\168\u03a0\138\38\58\u03a3\n8\39\39\39\3")
        buf.write("9\59\u03a9\n9\39\59\u03ac\n9\59\u03ae\n9\39\39\59\u03b2")
        buf.write("\n9\39\59\u03b5\n9\59\u03b7\n9\3:\3:\5:\u03bb\n:\3;\3")
        buf.write(";\3;\3;\3;\5;\u03c2\n;\3<\3<\3<\3<\5<\u03c8\n<\5<\u03ca")
        buf.write("\n<\3<\2\6LNPZ=\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36")
        buf.write(" \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt")
        buf.write("v\2\f\3\3\5\5\3\2+,\3\2HT\4\29:>>\5\2..;=FF\3\29:\3\2")
        buf.write("\678\4\2)*bb\3\2VY\4\2..\62\62\2\u0459\2{\3\2\2\2\4\u0084")
        buf.write("\3\2\2\2\6\u0088\3\2\2\2\b\u008c\3\2\2\2\n\u0095\3\2\2")
        buf.write("\2\f\u00e1\3\2\2\2\16\u00ed\3\2\2\2\20\u00ef\3\2\2\2\22")
        buf.write("\u00fa\3\2\2\2\24\u00ff\3\2\2\2\26\u0103\3\2\2\2\30\u0107")
        buf.write("\3\2\2\2\32\u010c\3\2\2\2\34\u011f\3\2\2\2\36\u012c\3")
        buf.write("\2\2\2 \u0154\3\2\2\2\"\u0156\3\2\2\2$\u0159\3\2\2\2&")
        buf.write("\u015c\3\2\2\2(\u016a\3\2\2\2*\u016c\3\2\2\2,\u0171\3")
        buf.write("\2\2\2.\u01fa\3\2\2\2\60\u020b\3\2\2\2\62\u020d\3\2\2")
        buf.write("\2\64\u022e\3\2\2\2\66\u0230\3\2\2\28\u023b\3\2\2\2:\u0246")
        buf.write("\3\2\2\2<\u024b\3\2\2\2>\u0253\3\2\2\2@\u0266\3\2\2\2")
        buf.write("B\u0280\3\2\2\2D\u0282\3\2\2\2F\u0290\3\2\2\2H\u0292\3")
        buf.write("\2\2\2J\u0295\3\2\2\2L\u029c\3\2\2\2N\u02a9\3\2\2\2P\u02d1")
        buf.write("\3\2\2\2R\u0312\3\2\2\2T\u0333\3\2\2\2V\u0337\3\2\2\2")
        buf.write("X\u0349\3\2\2\2Z\u0354\3\2\2\2\\\u035f\3\2\2\2^\u0364")
        buf.write("\3\2\2\2`\u0366\3\2\2\2b\u0368\3\2\2\2d\u036f\3\2\2\2")
        buf.write("f\u0377\3\2\2\2h\u0382\3\2\2\2j\u0384\3\2\2\2l\u0397\3")
        buf.write("\2\2\2n\u0399\3\2\2\2p\u03b6\3\2\2\2r\u03b8\3\2\2\2t\u03bc")
        buf.write("\3\2\2\2v\u03c9\3\2\2\2x|\5\4\3\2y|\5\6\4\2z|\5\b\5\2")
        buf.write("{x\3\2\2\2{y\3\2\2\2{z\3\2\2\2{|\3\2\2\2|}\3\2\2\2}~\7")
        buf.write("\2\2\3~\3\3\2\2\2\177\u0085\7\5\2\2\u0080\u0085\5,\27")
        buf.write("\2\u0081\u0082\5\f\7\2\u0082\u0083\7\5\2\2\u0083\u0085")
        buf.write("\3\2\2\2\u0084\177\3\2\2\2\u0084\u0080\3\2\2\2\u0084\u0081")
        buf.write("\3\2\2\2\u0085\5\3\2\2\2\u0086\u0089\7\5\2\2\u0087\u0089")
        buf.write("\5\n\6\2\u0088\u0086\3\2\2\2\u0088\u0087\3\2\2\2\u0089")
        buf.write("\u008a\3\2\2\2\u008a\u0088\3\2\2\2\u008a\u008b\3\2\2\2")
        buf.write("\u008b\7\3\2\2\2\u008c\u0090\5X-\2\u008d\u008f\7\5\2\2")
        buf.write("\u008e\u008d\3\2\2\2\u008f\u0092\3\2\2\2\u0090\u008e\3")
        buf.write("\2\2\2\u0090\u0091\3\2\2\2\u0091\t\3\2\2\2\u0092\u0090")
        buf.write("\3\2\2\2\u0093\u0096\5,\27\2\u0094\u0096\5\f\7\2\u0095")
        buf.write("\u0093\3\2\2\2\u0095\u0094\3\2\2\2\u0096\13\3\2\2\2\u0097")
        buf.write("\u0098\7\17\2\2\u0098\u0099\5@!\2\u0099\u009a\7\60\2\2")
        buf.write("\u009a\u009e\5\16\b\2\u009b\u009d\5\22\n\2\u009c\u009b")
        buf.write("\3\2\2\2\u009d\u00a0\3\2\2\2\u009e\u009c\3\2\2\2\u009e")
        buf.write("\u009f\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0\u009e\3\2\2\2")
        buf.write("\u00a1\u00a3\5\24\13\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3")
        buf.write("\3\2\2\2\u00a3\u00e2\3\2\2\2\u00a4\u00a5\7\22\2\2\u00a5")
        buf.write("\u00a6\5@!\2\u00a6\u00a7\7\60\2\2\u00a7\u00a9\5\16\b\2")
        buf.write("\u00a8\u00aa\5\24\13\2\u00a9\u00a8\3\2\2\2\u00a9\u00aa")
        buf.write("\3\2\2\2\u00aa\u00e2\3\2\2\2\u00ab\u00ad\7%\2\2\u00ac")
        buf.write("\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00ae\3\2\2\2")
        buf.write("\u00ae\u00af\7\23\2\2\u00af\u00b0\5\66\34\2\u00b0\u00b1")
        buf.write("\7\24\2\2\u00b1\u00b2\5X-\2\u00b2\u00b3\7\60\2\2\u00b3")
        buf.write("\u00b5\5\16\b\2\u00b4\u00b6\5\24\13\2\u00b5\u00b4\3\2")
        buf.write("\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00e2\3\2\2\2\u00b7\u00b8")
        buf.write("\7\25\2\2\u00b8\u00b9\7\60\2\2\u00b9\u00c6\5\16\b\2\u00ba")
        buf.write("\u00bc\5\32\16\2\u00bb\u00ba\3\2\2\2\u00bc\u00bd\3\2\2")
        buf.write("\2\u00bd\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00c0")
        buf.write("\3\2\2\2\u00bf\u00c1\5\24\13\2\u00c0\u00bf\3\2\2\2\u00c0")
        buf.write("\u00c1\3\2\2\2\u00c1\u00c3\3\2\2\2\u00c2\u00c4\5\26\f")
        buf.write("\2\u00c3\u00c2\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c7")
        buf.write("\3\2\2\2\u00c5\u00c7\5\26\f\2\u00c6\u00bb\3\2\2\2\u00c6")
        buf.write("\u00c5\3\2\2\2\u00c7\u00e2\3\2\2\2\u00c8\u00ca\7%\2\2")
        buf.write("\u00c9\u00c8\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\3")
        buf.write("\2\2\2\u00cb\u00cc\7\30\2\2\u00cc\u00d1\5\30\r\2\u00cd")
        buf.write("\u00ce\7/\2\2\u00ce\u00d0\5\30\r\2\u00cf\u00cd\3\2\2\2")
        buf.write("\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d2\3")
        buf.write("\2\2\2\u00d2\u00d4\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d5")
        buf.write("\7\60\2\2\u00d5\u00d6\5\16\b\2\u00d6\u00e2\3\2\2\2\u00d7")
        buf.write("\u00d9\5\20\t\2\u00d8\u00d7\3\2\2\2\u00d9\u00dc\3\2\2")
        buf.write("\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00df")
        buf.write("\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00e0\5\34\17\2\u00de")
        buf.write("\u00e0\5\36\20\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2")
        buf.write("\2\u00e0\u00e2\3\2\2\2\u00e1\u0097\3\2\2\2\u00e1\u00a4")
        buf.write("\3\2\2\2\u00e1\u00ac\3\2\2\2\u00e1\u00b7\3\2\2\2\u00e1")
        buf.write("\u00c9\3\2\2\2\u00e1\u00da\3\2\2\2\u00e2\r\3\2\2\2\u00e3")
        buf.write("\u00ee\5,\27\2\u00e4\u00e5\7\5\2\2\u00e5\u00e7\7\3\2\2")
        buf.write("\u00e6\u00e8\5\n\6\2\u00e7\u00e6\3\2\2\2\u00e8\u00e9\3")
        buf.write("\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00eb")
        buf.write("\3\2\2\2\u00eb\u00ec\7\4\2\2\u00ec\u00ee\3\2\2\2\u00ed")
        buf.write("\u00e3\3\2\2\2\u00ed\u00e4\3\2\2\2\u00ee\17\3\2\2\2\u00ef")
        buf.write("\u00f0\7F\2\2\u00f0\u00f6\5Z.\2\u00f1\u00f3\7\\\2\2\u00f2")
        buf.write("\u00f4\5j\66\2\u00f3\u00f2\3\2\2\2\u00f3\u00f4\3\2\2\2")
        buf.write("\u00f4\u00f5\3\2\2\2\u00f5\u00f7\7]\2\2\u00f6\u00f1\3")
        buf.write("\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9")
        buf.write("\7\5\2\2\u00f9\21\3\2\2\2\u00fa\u00fb\7\20\2\2\u00fb\u00fc")
        buf.write("\5@!\2\u00fc\u00fd\7\60\2\2\u00fd\u00fe\5\16\b\2\u00fe")
        buf.write("\23\3\2\2\2\u00ff\u0100\7\21\2\2\u0100\u0101\7\60\2\2")
        buf.write("\u0101\u0102\5\16\b\2\u0102\25\3\2\2\2\u0103\u0104\7\27")
        buf.write("\2\2\u0104\u0105\7\60\2\2\u0105\u0106\5\16\b\2\u0106\27")
        buf.write("\3\2\2\2\u0107\u010a\5@!\2\u0108\u0109\7\f\2\2\u0109\u010b")
        buf.write("\5P)\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b\31")
        buf.write("\3\2\2\2\u010c\u011a\7\31\2\2\u010d\u0118\5@!\2\u010e")
        buf.write("\u010f\6\16\2\2\u010f\u0110\7/\2\2\u0110\u0111\5\\/\2")
        buf.write("\u0111\u0112\b\16\1\2\u0112\u0119\3\2\2\2\u0113\u0114")
        buf.write("\6\16\3\2\u0114\u0115\7\f\2\2\u0115\u0116\5\\/\2\u0116")
        buf.write("\u0117\b\16\1\2\u0117\u0119\3\2\2\2\u0118\u010e\3\2\2")
        buf.write("\2\u0118\u0113\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b")
        buf.write("\3\2\2\2\u011a\u010d\3\2\2\2\u011a\u011b\3\2\2\2\u011b")
        buf.write("\u011c\3\2\2\2\u011c\u011d\7\60\2\2\u011d\u011e\5\16\b")
        buf.write("\2\u011e\33\3\2\2\2\u011f\u0120\7\37\2\2\u0120\u0126\5")
        buf.write("\\/\2\u0121\u0123\7\\\2\2\u0122\u0124\5j\66\2\u0123\u0122")
        buf.write("\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0125\3\2\2\2\u0125")
        buf.write("\u0127\7]\2\2\u0126\u0121\3\2\2\2\u0126\u0127\3\2\2\2")
        buf.write("\u0127\u0128\3\2\2\2\u0128\u0129\7\60\2\2\u0129\u012a")
        buf.write("\5\16\b\2\u012a\35\3\2\2\2\u012b\u012d\7%\2\2\u012c\u012b")
        buf.write("\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012e\3\2\2\2\u012e")
        buf.write("\u012f\7\6\2\2\u012f\u0130\5\\/\2\u0130\u0132\7\\\2\2")
        buf.write("\u0131\u0133\5 \21\2\u0132\u0131\3\2\2\2\u0132\u0133\3")
        buf.write("\2\2\2\u0133\u0134\3\2\2\2\u0134\u0137\7]\2\2\u0135\u0136")
        buf.write("\7G\2\2\u0136\u0138\5@!\2\u0137\u0135\3\2\2\2\u0137\u0138")
        buf.write("\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013a\7\60\2\2\u013a")
        buf.write("\u013b\5\16\b\2\u013b\37\3\2\2\2\u013c\u013d\5&\24\2\u013d")
        buf.write("\u013e\7/\2\2\u013e\u0140\3\2\2\2\u013f\u013c\3\2\2\2")
        buf.write("\u013f\u0140\3\2\2\2\u0140\u014b\3\2\2\2\u0141\u0144\5")
        buf.write("\"\22\2\u0142\u0143\7/\2\2\u0143\u0145\5&\24\2\u0144\u0142")
        buf.write("\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0148\3\2\2\2\u0146")
        buf.write("\u0147\7/\2\2\u0147\u0149\5$\23\2\u0148\u0146\3\2\2\2")
        buf.write("\u0148\u0149\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u014c\5")
        buf.write("$\23\2\u014b\u0141\3\2\2\2\u014b\u014a\3\2\2\2\u014c\u014e")
        buf.write("\3\2\2\2\u014d\u014f\7/\2\2\u014e\u014d\3\2\2\2\u014e")
        buf.write("\u014f\3\2\2\2\u014f\u0155\3\2\2\2\u0150\u0152\5&\24\2")
        buf.write("\u0151\u0153\7/\2\2\u0152\u0151\3\2\2\2\u0152\u0153\3")
        buf.write("\2\2\2\u0153\u0155\3\2\2\2\u0154\u013f\3\2\2\2\u0154\u0150")
        buf.write("\3\2\2\2\u0155!\3\2\2\2\u0156\u0157\7.\2\2\u0157\u0158")
        buf.write("\5*\26\2\u0158#\3\2\2\2\u0159\u015a\7\62\2\2\u015a\u015b")
        buf.write("\5*\26\2\u015b%\3\2\2\2\u015c\u0161\5(\25\2\u015d\u015e")
        buf.write("\7/\2\2\u015e\u0160\5(\25\2\u015f\u015d\3\2\2\2\u0160")
        buf.write("\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2")
        buf.write("\u0162\'\3\2\2\2\u0163\u0161\3\2\2\2\u0164\u0167\5*\26")
        buf.write("\2\u0165\u0166\7\63\2\2\u0166\u0168\5@!\2\u0167\u0165")
        buf.write("\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u016b\3\2\2\2\u0169")
        buf.write("\u016b\7.\2\2\u016a\u0164\3\2\2\2\u016a\u0169\3\2\2\2")
        buf.write("\u016b)\3\2\2\2\u016c\u016f\5\\/\2\u016d\u016e\7\60\2")
        buf.write("\2\u016e\u0170\5@!\2\u016f\u016d\3\2\2\2\u016f\u0170\3")
        buf.write("\2\2\2\u0170+\3\2\2\2\u0171\u0176\5.\30\2\u0172\u0173")
        buf.write("\7\61\2\2\u0173\u0175\5.\30\2\u0174\u0172\3\2\2\2\u0175")
        buf.write("\u0178\3\2\2\2\u0176\u0174\3\2\2\2\u0176\u0177\3\2\2\2")
        buf.write("\u0177\u017a\3\2\2\2\u0178\u0176\3\2\2\2\u0179\u017b\7")
        buf.write("\61\2\2\u017a\u0179\3\2\2\2\u017a\u017b\3\2\2\2\u017b")
        buf.write("\u017c\3\2\2\2\u017c\u017d\t\2\2\2\u017d-\3\2\2\2\u017e")
        buf.write("\u0180\5\60\31\2\u017f\u0181\5\64\33\2\u0180\u017f\3\2")
        buf.write("\2\2\u0180\u0181\3\2\2\2\u0181\u01fb\3\2\2\2\u0182\u0183")
        buf.write("\6\30\4\2\u0183\u019a\7\'\2\2\u0184\u0189\5@!\2\u0185")
        buf.write("\u0186\7/\2\2\u0186\u0188\5@!\2\u0187\u0185\3\2\2\2\u0188")
        buf.write("\u018b\3\2\2\2\u0189\u0187\3\2\2\2\u0189\u018a\3\2\2\2")
        buf.write("\u018a\u018d\3\2\2\2\u018b\u0189\3\2\2\2\u018c\u018e\7")
        buf.write("/\2\2\u018d\u018c\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u019b")
        buf.write("\3\2\2\2\u018f\u0190\78\2\2\u0190\u0193\5@!\2\u0191\u0192")
        buf.write("\7/\2\2\u0192\u0194\5@!\2\u0193\u0191\3\2\2\2\u0194\u0195")
        buf.write("\3\2\2\2\u0195\u0193\3\2\2\2\u0195\u0196\3\2\2\2\u0196")
        buf.write("\u0198\3\2\2\2\u0197\u0199\7/\2\2\u0198\u0197\3\2\2\2")
        buf.write("\u0198\u0199\3\2\2\2\u0199\u019b\3\2\2\2\u019a\u0184\3")
        buf.write("\2\2\2\u019a\u018f\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u019d")
        buf.write("\b\30\1\2\u019d\u01fb\3\2\2\2\u019e\u019f\7!\2\2\u019f")
        buf.write("\u01fb\5\66\34\2\u01a0\u01fb\7\"\2\2\u01a1\u01fb\7$\2")
        buf.write("\2\u01a2\u01fb\7#\2\2\u01a3\u01a5\7\7\2\2\u01a4\u01a6")
        buf.write("\5X-\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01fb")
        buf.write("\3\2\2\2\u01a7\u01b1\7\b\2\2\u01a8\u01af\5@!\2\u01a9\u01aa")
        buf.write("\7/\2\2\u01aa\u01ad\5@!\2\u01ab\u01ac\7/\2\2\u01ac\u01ae")
        buf.write("\5@!\2\u01ad\u01ab\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0")
        buf.write("\3\2\2\2\u01af\u01a9\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0")
        buf.write("\u01b2\3\2\2\2\u01b1\u01a8\3\2\2\2\u01b1\u01b2\3\2\2\2")
        buf.write("\u01b2\u01b5\3\2\2\2\u01b3\u01b4\7\t\2\2\u01b4\u01b6\5")
        buf.write("@!\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01fb")
        buf.write("\3\2\2\2\u01b7\u01fb\5b\62\2\u01b8\u01b9\7\n\2\2\u01b9")
        buf.write("\u01fb\5<\37\2\u01ba\u01c7\7\t\2\2\u01bb\u01bd\t\3\2\2")
        buf.write("\u01bc\u01bb\3\2\2\2\u01bd\u01c0\3\2\2\2\u01be\u01bc\3")
        buf.write("\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c1\3\2\2\2\u01c0\u01be")
        buf.write("\3\2\2\2\u01c1\u01c8\5Z.\2\u01c2\u01c4\t\3\2\2\u01c3\u01c2")
        buf.write("\3\2\2\2\u01c4\u01c5\3\2\2\2\u01c5\u01c3\3\2\2\2\u01c5")
        buf.write("\u01c6\3\2\2\2\u01c6\u01c8\3\2\2\2\u01c7\u01be\3\2\2\2")
        buf.write("\u01c7\u01c3\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01d0\7")
        buf.write("\n\2\2\u01ca\u01d1\7.\2\2\u01cb\u01cc\7\\\2\2\u01cc\u01cd")
        buf.write("\58\35\2\u01cd\u01ce\7]\2\2\u01ce\u01d1\3\2\2\2\u01cf")
        buf.write("\u01d1\58\35\2\u01d0\u01ca\3\2\2\2\u01d0\u01cb\3\2\2\2")
        buf.write("\u01d0\u01cf\3\2\2\2\u01d1\u01fb\3\2\2\2\u01d2\u01d3\7")
        buf.write("\r\2\2\u01d3\u01d8\5\\/\2\u01d4\u01d5\7/\2\2\u01d5\u01d7")
        buf.write("\5\\/\2\u01d6\u01d4\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8")
        buf.write("\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01fb\3\2\2\2")
        buf.write("\u01da\u01d8\3\2\2\2\u01db\u01dc\6\30\5\2\u01dc\u01dd")
        buf.write("\7(\2\2\u01dd\u01e4\5P)\2\u01de\u01df\7\24\2\2\u01df\u01e2")
        buf.write("\5@!\2\u01e0\u01e1\7/\2\2\u01e1\u01e3\5@!\2\u01e2\u01e0")
        buf.write("\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4")
        buf.write("\u01de\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6\3\2\2\2")
        buf.write("\u01e6\u01e7\b\30\1\2\u01e7\u01fb\3\2\2\2\u01e8\u01e9")
        buf.write("\7\16\2\2\u01e9\u01ec\5@!\2\u01ea\u01eb\7/\2\2\u01eb\u01ed")
        buf.write("\5@!\2\u01ec\u01ea\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01fb")
        buf.write("\3\2\2\2\u01ee\u01ef\6\30\6\2\u01ef\u01f0\7\13\2\2\u01f0")
        buf.write("\u01f5\5\\/\2\u01f1\u01f2\7/\2\2\u01f2\u01f4\5\\/\2\u01f3")
        buf.write("\u01f1\3\2\2\2\u01f4\u01f7\3\2\2\2\u01f5\u01f3\3\2\2\2")
        buf.write("\u01f5\u01f6\3\2\2\2\u01f6\u01f8\3\2\2\2\u01f7\u01f5\3")
        buf.write("\2\2\2\u01f8\u01f9\b\30\1\2\u01f9\u01fb\3\2\2\2\u01fa")
        buf.write("\u017e\3\2\2\2\u01fa\u0182\3\2\2\2\u01fa\u019e\3\2\2\2")
        buf.write("\u01fa\u01a0\3\2\2\2\u01fa\u01a1\3\2\2\2\u01fa\u01a2\3")
        buf.write("\2\2\2\u01fa\u01a3\3\2\2\2\u01fa\u01a7\3\2\2\2\u01fa\u01b7")
        buf.write("\3\2\2\2\u01fa\u01b8\3\2\2\2\u01fa\u01ba\3\2\2\2\u01fa")
        buf.write("\u01d2\3\2\2\2\u01fa\u01db\3\2\2\2\u01fa\u01e8\3\2\2\2")
        buf.write("\u01fa\u01ee\3\2\2\2\u01fb/\3\2\2\2\u01fc\u01ff\5@!\2")
        buf.write("\u01fd\u01ff\5\62\32\2\u01fe\u01fc\3\2\2\2\u01fe\u01fd")
        buf.write("\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0201\7/\2\2\u0201")
        buf.write("\u0203\3\2\2\2\u0202\u01fe\3\2\2\2\u0203\u0204\3\2\2\2")
        buf.write("\u0204\u0202\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0208\3")
        buf.write("\2\2\2\u0206\u0209\5@!\2\u0207\u0209\5\62\32\2\u0208\u0206")
        buf.write("\3\2\2\2\u0208\u0207\3\2\2\2\u0208\u0209\3\2\2\2\u0209")
        buf.write("\u020c\3\2\2\2\u020a\u020c\5X-\2\u020b\u0202\3\2\2\2\u020b")
        buf.write("\u020a\3\2\2\2\u020c\61\3\2\2\2\u020d\u020e\7.\2\2\u020e")
        buf.write("\u020f\5P)\2\u020f\63\3\2\2\2\u0210\u021e\7\63\2\2\u0211")
        buf.write("\u0216\5\60\31\2\u0212\u0213\7\63\2\2\u0213\u0215\5\60")
        buf.write("\31\2\u0214\u0212\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214")
        buf.write("\3\2\2\2\u0216\u0217\3\2\2\2\u0217\u021b\3\2\2\2\u0218")
        buf.write("\u0216\3\2\2\2\u0219\u021a\7\63\2\2\u021a\u021c\5b\62")
        buf.write("\2\u021b\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021f")
        buf.write("\3\2\2\2\u021d\u021f\5b\62\2\u021e\u0211\3\2\2\2\u021e")
        buf.write("\u021d\3\2\2\2\u021f\u022f\3\2\2\2\u0220\u0221\6\33\7")
        buf.write("\2\u0221\u0222\7\60\2\2\u0222\u0225\5@!\2\u0223\u0224")
        buf.write("\7\63\2\2\u0224\u0226\5X-\2\u0225\u0223\3\2\2\2\u0225")
        buf.write("\u0226\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\b\33\1")
        buf.write("\2\u0228\u022f\3\2\2\2\u0229\u022c\t\4\2\2\u022a\u022d")
        buf.write("\5b\62\2\u022b\u022d\5X-\2\u022c\u022a\3\2\2\2\u022c\u022b")
        buf.write("\3\2\2\2\u022d\u022f\3\2\2\2\u022e\u0210\3\2\2\2\u022e")
        buf.write("\u0220\3\2\2\2\u022e\u0229\3\2\2\2\u022f\65\3\2\2\2\u0230")
        buf.write("\u0235\5P)\2\u0231\u0232\7/\2\2\u0232\u0234\5P)\2\u0233")
        buf.write("\u0231\3\2\2\2\u0234\u0237\3\2\2\2\u0235\u0233\3\2\2\2")
        buf.write("\u0235\u0236\3\2\2\2\u0236\u0239\3\2\2\2\u0237\u0235\3")
        buf.write("\2\2\2\u0238\u023a\7/\2\2\u0239\u0238\3\2\2\2\u0239\u023a")
        buf.write("\3\2\2\2\u023a\67\3\2\2\2\u023b\u0240\5:\36\2\u023c\u023d")
        buf.write("\7/\2\2\u023d\u023f\5:\36\2\u023e\u023c\3\2\2\2\u023f")
        buf.write("\u0242\3\2\2\2\u0240\u023e\3\2\2\2\u0240\u0241\3\2\2\2")
        buf.write("\u0241\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0243\u0245\7")
        buf.write("/\2\2\u0244\u0243\3\2\2\2\u0244\u0245\3\2\2\2\u02459\3")
        buf.write("\2\2\2\u0246\u0249\5\\/\2\u0247\u0248\7\f\2\2\u0248\u024a")
        buf.write("\5\\/\2\u0249\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024a")
        buf.write(";\3\2\2\2\u024b\u0250\5> \2\u024c\u024d\7/\2\2\u024d\u024f")
        buf.write("\5> \2\u024e\u024c\3\2\2\2\u024f\u0252\3\2\2\2\u0250\u024e")
        buf.write("\3\2\2\2\u0250\u0251\3\2\2\2\u0251=\3\2\2\2\u0252\u0250")
        buf.write("\3\2\2\2\u0253\u0256\5Z.\2\u0254\u0255\7\f\2\2\u0255\u0257")
        buf.write("\5\\/\2\u0256\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257")
        buf.write("?\3\2\2\2\u0258\u025e\5L\'\2\u0259\u025a\7\17\2\2\u025a")
        buf.write("\u025b\5L\'\2\u025b\u025c\7\21\2\2\u025c\u025d\5@!\2\u025d")
        buf.write("\u025f\3\2\2\2\u025e\u0259\3\2\2\2\u025e\u025f\3\2\2\2")
        buf.write("\u025f\u0267\3\2\2\2\u0260\u0262\7\32\2\2\u0261\u0263")
        buf.write("\5B\"\2\u0262\u0261\3\2\2\2\u0262\u0263\3\2\2\2\u0263")
        buf.write("\u0264\3\2\2\2\u0264\u0265\7\60\2\2\u0265\u0267\5@!\2")
        buf.write("\u0266\u0258\3\2\2\2\u0266\u0260\3\2\2\2\u0267A\3\2\2")
        buf.write("\2\u0268\u0269\5D#\2\u0269\u026a\7/\2\2\u026a\u026c\3")
        buf.write("\2\2\2\u026b\u0268\3\2\2\2\u026b\u026c\3\2\2\2\u026c\u0277")
        buf.write("\3\2\2\2\u026d\u0270\5H%\2\u026e\u026f\7/\2\2\u026f\u0271")
        buf.write("\5D#\2\u0270\u026e\3\2\2\2\u0270\u0271\3\2\2\2\u0271\u0274")
        buf.write("\3\2\2\2\u0272\u0273\7/\2\2\u0273\u0275\5J&\2\u0274\u0272")
        buf.write("\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0278\3\2\2\2\u0276")
        buf.write("\u0278\5J&\2\u0277\u026d\3\2\2\2\u0277\u0276\3\2\2\2\u0278")
        buf.write("\u027a\3\2\2\2\u0279\u027b\7/\2\2\u027a\u0279\3\2\2\2")
        buf.write("\u027a\u027b\3\2\2\2\u027b\u0281\3\2\2\2\u027c\u027e\5")
        buf.write("D#\2\u027d\u027f\7/\2\2\u027e\u027d\3\2\2\2\u027e\u027f")
        buf.write("\3\2\2\2\u027f\u0281\3\2\2\2\u0280\u026b\3\2\2\2\u0280")
        buf.write("\u027c\3\2\2\2\u0281C\3\2\2\2\u0282\u0287\5F$\2\u0283")
        buf.write("\u0284\7/\2\2\u0284\u0286\5F$\2\u0285\u0283\3\2\2\2\u0286")
        buf.write("\u0289\3\2\2\2\u0287\u0285\3\2\2\2\u0287\u0288\3\2\2\2")
        buf.write("\u0288E\3\2\2\2\u0289\u0287\3\2\2\2\u028a\u028d\5\\/\2")
        buf.write("\u028b\u028c\7\63\2\2\u028c\u028e\5@!\2\u028d\u028b\3")
        buf.write("\2\2\2\u028d\u028e\3\2\2\2\u028e\u0291\3\2\2\2\u028f\u0291")
        buf.write("\7.\2\2\u0290\u028a\3\2\2\2\u0290\u028f\3\2\2\2\u0291")
        buf.write("G\3\2\2\2\u0292\u0293\7.\2\2\u0293\u0294\5\\/\2\u0294")
        buf.write("I\3\2\2\2\u0295\u0296\7\62\2\2\u0296\u0297\5\\/\2\u0297")
        buf.write("K\3\2\2\2\u0298\u0299\b\'\1\2\u0299\u029d\5N(\2\u029a")
        buf.write("\u029b\7\35\2\2\u029b\u029d\5L\'\5\u029c\u0298\3\2\2\2")
        buf.write("\u029c\u029a\3\2\2\2\u029d\u02a6\3\2\2\2\u029e\u029f\f")
        buf.write("\4\2\2\u029f\u02a0\7\34\2\2\u02a0\u02a5\5L\'\5\u02a1\u02a2")
        buf.write("\f\3\2\2\u02a2\u02a3\7\33\2\2\u02a3\u02a5\5L\'\4\u02a4")
        buf.write("\u029e\3\2\2\2\u02a4\u02a1\3\2\2\2\u02a5\u02a8\3\2\2\2")
        buf.write("\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7M\3\2\2")
        buf.write("\2\u02a8\u02a6\3\2\2\2\u02a9\u02aa\b(\1\2\u02aa\u02ab")
        buf.write("\5P)\2\u02ab\u02c1\3\2\2\2\u02ac\u02bc\f\4\2\2\u02ad\u02bd")
        buf.write("\7?\2\2\u02ae\u02bd\7@\2\2\u02af\u02bd\7A\2\2\u02b0\u02bd")
        buf.write("\7B\2\2\u02b1\u02bd\7C\2\2\u02b2\u02bd\7D\2\2\u02b3\u02bd")
        buf.write("\7E\2\2\u02b4\u02b6\7\35\2\2\u02b5\u02b4\3\2\2\2\u02b5")
        buf.write("\u02b6\3\2\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02bd\7\24\2")
        buf.write("\2\u02b8\u02ba\7\36\2\2\u02b9\u02bb\7\35\2\2\u02ba\u02b9")
        buf.write("\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd\3\2\2\2\u02bc")
        buf.write("\u02ad\3\2\2\2\u02bc\u02ae\3\2\2\2\u02bc\u02af\3\2\2\2")
        buf.write("\u02bc\u02b0\3\2\2\2\u02bc\u02b1\3\2\2\2\u02bc\u02b2\3")
        buf.write("\2\2\2\u02bc\u02b3\3\2\2\2\u02bc\u02b5\3\2\2\2\u02bc\u02b8")
        buf.write("\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02c0\5N(\5\u02bf\u02ac")
        buf.write("\3\2\2\2\u02c0\u02c3\3\2\2\2\u02c1\u02bf\3\2\2\2\u02c1")
        buf.write("\u02c2\3\2\2\2\u02c2O\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c4")
        buf.write("\u02c6\b)\1\2\u02c5\u02c7\7&\2\2\u02c6\u02c5\3\2\2\2\u02c6")
        buf.write("\u02c7\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8\u02cc\5R*\2\u02c9")
        buf.write("\u02cb\5f\64\2\u02ca\u02c9\3\2\2\2\u02cb\u02ce\3\2\2\2")
        buf.write("\u02cc\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u02d2\3")
        buf.write("\2\2\2\u02ce\u02cc\3\2\2\2\u02cf\u02d0\t\5\2\2\u02d0\u02d2")
        buf.write("\5P)\t\u02d1\u02c4\3\2\2\2\u02d1\u02cf\3\2\2\2\u02d2\u02ea")
        buf.write("\3\2\2\2\u02d3\u02d4\f\n\2\2\u02d4\u02d5\7\62\2\2\u02d5")
        buf.write("\u02e9\5P)\n\u02d6\u02d7\f\b\2\2\u02d7\u02d8\t\6\2\2\u02d8")
        buf.write("\u02e9\5P)\t\u02d9\u02da\f\7\2\2\u02da\u02db\t\7\2\2\u02db")
        buf.write("\u02e9\5P)\b\u02dc\u02dd\f\6\2\2\u02dd\u02de\t\b\2\2\u02de")
        buf.write("\u02e9\5P)\7\u02df\u02e0\f\5\2\2\u02e0\u02e1\7\66\2\2")
        buf.write("\u02e1\u02e9\5P)\6\u02e2\u02e3\f\4\2\2\u02e3\u02e4\7\65")
        buf.write("\2\2\u02e4\u02e9\5P)\5\u02e5\u02e6\f\3\2\2\u02e6\u02e7")
        buf.write("\7\64\2\2\u02e7\u02e9\5P)\4\u02e8\u02d3\3\2\2\2\u02e8")
        buf.write("\u02d6\3\2\2\2\u02e8\u02d9\3\2\2\2\u02e8\u02dc\3\2\2\2")
        buf.write("\u02e8\u02df\3\2\2\2\u02e8\u02e2\3\2\2\2\u02e8\u02e5\3")
        buf.write("\2\2\2\u02e9\u02ec\3\2\2\2\u02ea\u02e8\3\2\2\2\u02ea\u02eb")
        buf.write("\3\2\2\2\u02ebQ\3\2\2\2\u02ec\u02ea\3\2\2\2\u02ed\u02f0")
        buf.write("\7\\\2\2\u02ee\u02f1\5b\62\2\u02ef\u02f1\5V,\2\u02f0\u02ee")
        buf.write("\3\2\2\2\u02f0\u02ef\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1")
        buf.write("\u02f2\3\2\2\2\u02f2\u0313\7]\2\2\u02f3\u02f5\7`\2\2\u02f4")
        buf.write("\u02f6\5V,\2\u02f5\u02f4\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6")
        buf.write("\u02f7\3\2\2\2\u02f7\u0313\7a\2\2\u02f8\u02fa\7^\2\2\u02f9")
        buf.write("\u02fb\5T+\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fb")
        buf.write("\u02fc\3\2\2\2\u02fc\u0313\7_\2\2\u02fd\u02fe\7-\2\2\u02fe")
        buf.write("\u0300\5X-\2\u02ff\u0301\7/\2\2\u0300\u02ff\3\2\2\2\u0300")
        buf.write("\u0301\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0303\7-\2\2")
        buf.write("\u0303\u0313\3\2\2\2\u0304\u0313\7,\2\2\u0305\u0313\5")
        buf.write("\\/\2\u0306\u0313\7\'\2\2\u0307\u0313\7(\2\2\u0308\u030a")
        buf.write("\7:\2\2\u0309\u0308\3\2\2\2\u0309\u030a\3\2\2\2\u030a")
        buf.write("\u030b\3\2\2\2\u030b\u0313\5^\60\2\u030c\u0313\7\26\2")
        buf.write("\2\u030d\u030f\7U\2\2\u030e\u030d\3\2\2\2\u030f\u0310")
        buf.write("\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u0311\3\2\2\2\u0311")
        buf.write("\u0313\3\2\2\2\u0312\u02ed\3\2\2\2\u0312\u02f3\3\2\2\2")
        buf.write("\u0312\u02f8\3\2\2\2\u0312\u02fd\3\2\2\2\u0312\u0304\3")
        buf.write("\2\2\2\u0312\u0305\3\2\2\2\u0312\u0306\3\2\2\2\u0312\u0307")
        buf.write("\3\2\2\2\u0312\u0309\3\2\2\2\u0312\u030c\3\2\2\2\u0312")
        buf.write("\u030e\3\2\2\2\u0313S\3\2\2\2\u0314\u0315\5@!\2\u0315")
        buf.write("\u0316\7\60\2\2\u0316\u0317\5@!\2\u0317\u031b\3\2\2\2")
        buf.write("\u0318\u0319\7\62\2\2\u0319\u031b\5P)\2\u031a\u0314\3")
        buf.write("\2\2\2\u031a\u0318\3\2\2\2\u031b\u0327\3\2\2\2\u031c\u0323")
        buf.write("\7/\2\2\u031d\u031e\5@!\2\u031e\u031f\7\60\2\2\u031f\u0320")
        buf.write("\5@!\2\u0320\u0324\3\2\2\2\u0321\u0322\7\62\2\2\u0322")
        buf.write("\u0324\5P)\2\u0323\u031d\3\2\2\2\u0323\u0321\3\2\2\2\u0324")
        buf.write("\u0326\3\2\2\2\u0325\u031c\3\2\2\2\u0326\u0329\3\2\2\2")
        buf.write("\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u032b\3")
        buf.write("\2\2\2\u0329\u0327\3\2\2\2\u032a\u032c\7/\2\2\u032b\u032a")
        buf.write("\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u0334\3\2\2\2\u032d")
        buf.write("\u032e\5@!\2\u032e\u032f\7\60\2\2\u032f\u0330\5@!\2\u0330")
        buf.write("\u0331\5t;\2\u0331\u0334\3\2\2\2\u0332\u0334\5V,\2\u0333")
        buf.write("\u031a\3\2\2\2\u0333\u032d\3\2\2\2\u0333\u0332\3\2\2\2")
        buf.write("\u0334U\3\2\2\2\u0335\u0338\5@!\2\u0336\u0338\5\62\32")
        buf.write("\2\u0337\u0335\3\2\2\2\u0337\u0336\3\2\2\2\u0338\u0347")
        buf.write("\3\2\2\2\u0339\u0348\5t;\2\u033a\u033d\7/\2\2\u033b\u033e")
        buf.write("\5@!\2\u033c\u033e\5\62\32\2\u033d\u033b\3\2\2\2\u033d")
        buf.write("\u033c\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u033a\3\2\2\2")
        buf.write("\u0340\u0343\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3")
        buf.write("\2\2\2\u0342\u0345\3\2\2\2\u0343\u0341\3\2\2\2\u0344\u0346")
        buf.write("\7/\2\2\u0345\u0344\3\2\2\2\u0345\u0346\3\2\2\2\u0346")
        buf.write("\u0348\3\2\2\2\u0347\u0339\3\2\2\2\u0347\u0341\3\2\2\2")
        buf.write("\u0348W\3\2\2\2\u0349\u034e\5@!\2\u034a\u034b\7/\2\2\u034b")
        buf.write("\u034d\5@!\2\u034c\u034a\3\2\2\2\u034d\u0350\3\2\2\2\u034e")
        buf.write("\u034c\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0352\3\2\2\2")
        buf.write("\u0350\u034e\3\2\2\2\u0351\u0353\7/\2\2\u0352\u0351\3")
        buf.write("\2\2\2\u0352\u0353\3\2\2\2\u0353Y\3\2\2\2\u0354\u0355")
        buf.write("\b.\1\2\u0355\u0356\5\\/\2\u0356\u035c\3\2\2\2\u0357\u0358")
        buf.write("\f\4\2\2\u0358\u0359\7+\2\2\u0359\u035b\5\\/\2\u035a\u0357")
        buf.write("\3\2\2\2\u035b\u035e\3\2\2\2\u035c\u035a\3\2\2\2\u035c")
        buf.write("\u035d\3\2\2\2\u035d[\3\2\2\2\u035e\u035c\3\2\2\2\u035f")
        buf.write("\u0360\t\t\2\2\u0360]\3\2\2\2\u0361\u0365\5`\61\2\u0362")
        buf.write("\u0365\7Z\2\2\u0363\u0365\7[\2\2\u0364\u0361\3\2\2\2\u0364")
        buf.write("\u0362\3\2\2\2\u0364\u0363\3\2\2\2\u0365_\3\2\2\2\u0366")
        buf.write("\u0367\t\n\2\2\u0367a\3\2\2\2\u0368\u036a\7 \2\2\u0369")
        buf.write("\u036b\5d\63\2\u036a\u0369\3\2\2\2\u036a\u036b\3\2\2\2")
        buf.write("\u036bc\3\2\2\2\u036c\u036d\7\t\2\2\u036d\u0370\5@!\2")
        buf.write("\u036e\u0370\5X-\2\u036f\u036c\3\2\2\2\u036f\u036e\3\2")
        buf.write("\2\2\u0370e\3\2\2\2\u0371\u0372\7+\2\2\u0372\u0374\5\\")
        buf.write("/\2\u0373\u0375\5h\65\2\u0374\u0373\3\2\2\2\u0374\u0375")
        buf.write("\3\2\2\2\u0375\u0378\3\2\2\2\u0376\u0378\5h\65\2\u0377")
        buf.write("\u0371\3\2\2\2\u0377\u0376\3\2\2\2\u0378g\3\2\2\2\u0379")
        buf.write("\u037b\7\\\2\2\u037a\u037c\5j\66\2\u037b\u037a\3\2\2\2")
        buf.write("\u037b\u037c\3\2\2\2\u037c\u037d\3\2\2\2\u037d\u0383\7")
        buf.write("]\2\2\u037e\u037f\7`\2\2\u037f\u0380\5n8\2\u0380\u0381")
        buf.write("\7a\2\2\u0381\u0383\3\2\2\2\u0382\u0379\3\2\2\2\u0382")
        buf.write("\u037e\3\2\2\2\u0383i\3\2\2\2\u0384\u0389\5l\67\2\u0385")
        buf.write("\u0386\7/\2\2\u0386\u0388\5l\67\2\u0387\u0385\3\2\2\2")
        buf.write("\u0388\u038b\3\2\2\2\u0389\u0387\3\2\2\2\u0389\u038a\3")
        buf.write("\2\2\2\u038a\u038d\3\2\2\2\u038b\u0389\3\2\2\2\u038c\u038e")
        buf.write("\7/\2\2\u038d\u038c\3\2\2\2\u038d\u038e\3\2\2\2\u038e")
        buf.write("k\3\2\2\2\u038f\u0393\5@!\2\u0390\u0394\5t;\2\u0391\u0392")
        buf.write("\7\63\2\2\u0392\u0394\5@!\2\u0393\u0390\3\2\2\2\u0393")
        buf.write("\u0391\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u0398\3\2\2\2")
        buf.write("\u0395\u0396\t\13\2\2\u0396\u0398\5@!\2\u0397\u038f\3")
        buf.write("\2\2\2\u0397\u0395\3\2\2\2\u0398m\3\2\2\2\u0399\u039e")
        buf.write("\5p9\2\u039a\u039b\7/\2\2\u039b\u039d\5p9\2\u039c\u039a")
        buf.write("\3\2\2\2\u039d\u03a0\3\2\2\2\u039e\u039c\3\2\2\2\u039e")
        buf.write("\u039f\3\2\2\2\u039f\u03a2\3\2\2\2\u03a0\u039e\3\2\2\2")
        buf.write("\u03a1\u03a3\7/\2\2\u03a2\u03a1\3\2\2\2\u03a2\u03a3\3")
        buf.write("\2\2\2\u03a3o\3\2\2\2\u03a4\u03b7\7,\2\2\u03a5\u03ad\5")
        buf.write("@!\2\u03a6\u03a8\7\60\2\2\u03a7\u03a9\5@!\2\u03a8\u03a7")
        buf.write("\3\2\2\2\u03a8\u03a9\3\2\2\2\u03a9\u03ab\3\2\2\2\u03aa")
        buf.write("\u03ac\5r:\2\u03ab\u03aa\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac")
        buf.write("\u03ae\3\2\2\2\u03ad\u03a6\3\2\2\2\u03ad\u03ae\3\2\2\2")
        buf.write("\u03ae\u03b7\3\2\2\2\u03af\u03b1\7\60\2\2\u03b0\u03b2")
        buf.write("\5@!\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b4")
        buf.write("\3\2\2\2\u03b3\u03b5\5r:\2\u03b4\u03b3\3\2\2\2\u03b4\u03b5")
        buf.write("\3\2\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03a4\3\2\2\2\u03b6")
        buf.write("\u03a5\3\2\2\2\u03b6\u03af\3\2\2\2\u03b7q\3\2\2\2\u03b8")
        buf.write("\u03ba\7\60\2\2\u03b9\u03bb\5@!\2\u03ba\u03b9\3\2\2\2")
        buf.write("\u03ba\u03bb\3\2\2\2\u03bbs\3\2\2\2\u03bc\u03bd\7\23\2")
        buf.write("\2\u03bd\u03be\5\66\34\2\u03be\u03bf\7\24\2\2\u03bf\u03c1")
        buf.write("\5L\'\2\u03c0\u03c2\5v<\2\u03c1\u03c0\3\2\2\2\u03c1\u03c2")
        buf.write("\3\2\2\2\u03c2u\3\2\2\2\u03c3\u03ca\5t;\2\u03c4\u03c5")
        buf.write("\7\17\2\2\u03c5\u03c7\5@!\2\u03c6\u03c8\5v<\2\u03c7\u03c6")
        buf.write("\3\2\2\2\u03c7\u03c8\3\2\2\2\u03c8\u03ca\3\2\2\2\u03c9")
        buf.write("\u03c3\3\2\2\2\u03c9\u03c4\3\2\2\2\u03caw\3\2\2\2\u0099")
        buf.write("{\u0084\u0088\u008a\u0090\u0095\u009e\u00a2\u00a9\u00ac")
        buf.write("\u00b5\u00bd\u00c0\u00c3\u00c6\u00c9\u00d1\u00da\u00df")
        buf.write("\u00e1\u00e9\u00ed\u00f3\u00f6\u010a\u0118\u011a\u0123")
        buf.write("\u0126\u012c\u0132\u0137\u013f\u0144\u0148\u014b\u014e")
        buf.write("\u0152\u0154\u0161\u0167\u016a\u016f\u0176\u017a\u0180")
        buf.write("\u0189\u018d\u0195\u0198\u019a\u01a5\u01ad\u01af\u01b1")
        buf.write("\u01b5\u01be\u01c5\u01c7\u01d0\u01d8\u01e2\u01e4\u01ec")
        buf.write("\u01f5\u01fa\u01fe\u0204\u0208\u020b\u0216\u021b\u021e")
        buf.write("\u0225\u022c\u022e\u0235\u0239\u0240\u0244\u0249\u0250")
        buf.write("\u0256\u025e\u0262\u0266\u026b\u0270\u0274\u0277\u027a")
        buf.write("\u027e\u0280\u0287\u028d\u0290\u029c\u02a4\u02a6\u02b5")
        buf.write("\u02ba\u02bc\u02c1\u02c6\u02cc\u02d1\u02e8\u02ea\u02f0")
        buf.write("\u02f5\u02fa\u0300\u0309\u0310\u0312\u031a\u0323\u0327")
        buf.write("\u032b\u0333\u0337\u033d\u0341\u0345\u0347\u034e\u0352")
        buf.write("\u035c\u0364\u036a\u036f\u0374\u0377\u037b\u0382\u0389")
        buf.write("\u038d\u0393\u0397\u039e\u03a2\u03a8\u03ab\u03ad\u03b1")
        buf.write("\u03b4\u03b6\u03ba\u03c1\u03c7\u03c9")
        return buf.getvalue()


class PythonParser ( PythonParserBase ):

    grammarFileName = "PythonParser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'def'", "'return'", "'raise'", "'from'", "'import'", 
                     "'nonlocal'", "'as'", "'global'", "'assert'", "'if'", 
                     "'elif'", "'else'", "'while'", "'for'", "'in'", "'try'", 
                     "'None'", "'finally'", "'with'", "'except'", "'lambda'", 
                     "'or'", "'and'", "'not'", "'is'", "'class'", "'yield'", 
                     "'del'", "'pass'", "'continue'", "'break'", "'async'", 
                     "'await'", "'print'", "'exec'", "'True'", "'False'", 
                     "'.'", "'...'", "'`'", "'*'", "','", "':'", "';'", 
                     "'**'", "'='", "'|'", "'^'", "'&'", "'<<'", "'>>'", 
                     "'+'", "'-'", "'/'", "'%'", "'//'", "'~'", "'<'", "'>'", 
                     "'=='", "'>='", "'<='", "'<>'", "'!='", "'@'", "'->'", 
                     "'+='", "'-='", "'*='", "'@='", "'/='", "'%='", "'&='", 
                     "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'('", "')'", 
                     "'{'", "'}'", "'['", "']'" ]

    symbolicNames = [ "<INVALID>", "INDENT", "DEDENT", "LINE_BREAK", "DEF", 
                      "RETURN", "RAISE", "FROM", "IMPORT", "NONLOCAL", "AS", 
                      "GLOBAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE", 
                      "FOR", "IN", "TRY", "NONE", "FINALLY", "WITH", "EXCEPT", 
                      "LAMBDA", "OR", "AND", "NOT", "IS", "CLASS", "YIELD", 
                      "DEL", "PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT", 
                      "PRINT", "EXEC", "TRUE", "FALSE", "DOT", "ELLIPSIS", 
                      "REVERSE_QUOTE", "STAR", "COMMA", "COLON", "SEMI_COLON", 
                      "POWER", "ASSIGN", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", 
                      "RIGHT_SHIFT", "ADD", "MINUS", "DIV", "MOD", "IDIV", 
                      "NOT_OP", "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", "STRING", "DECIMAL_INTEGER", "OCT_INTEGER", 
                      "HEX_INTEGER", "BIN_INTEGER", "IMAG_NUMBER", "FLOAT_NUMBER", 
                      "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACE", "CLOSE_BRACE", 
                      "OPEN_BRACKET", "CLOSE_BRACKET", "NAME", "LINE_JOIN", 
                      "NEWLINE", "WS", "COMMENT" ]

    RULE_root = 0
    RULE_single_input = 1
    RULE_file_input = 2
    RULE_eval_input = 3
    RULE_stmt = 4
    RULE_compound_stmt = 5
    RULE_suite = 6
    RULE_decorator = 7
    RULE_elif_clause = 8
    RULE_else_clause = 9
    RULE_finally_clause = 10
    RULE_with_item = 11
    RULE_except_clause = 12
    RULE_classdef = 13
    RULE_funcdef = 14
    RULE_typedargslist = 15
    RULE_args = 16
    RULE_kwargs = 17
    RULE_def_parameters = 18
    RULE_def_parameter = 19
    RULE_named_parameter = 20
    RULE_simple_stmt = 21
    RULE_small_stmt = 22
    RULE_testlist_star_expr = 23
    RULE_star_expr = 24
    RULE_assign_part = 25
    RULE_exprlist = 26
    RULE_import_as_names = 27
    RULE_import_as_name = 28
    RULE_dotted_as_names = 29
    RULE_dotted_as_name = 30
    RULE_test = 31
    RULE_varargslist = 32
    RULE_vardef_parameters = 33
    RULE_vardef_parameter = 34
    RULE_varargs = 35
    RULE_varkwargs = 36
    RULE_logical_test = 37
    RULE_comparison = 38
    RULE_expr = 39
    RULE_atom = 40
    RULE_dictorsetmaker = 41
    RULE_testlist_comp = 42
    RULE_testlist = 43
    RULE_dotted_name = 44
    RULE_name = 45
    RULE_number = 46
    RULE_integer = 47
    RULE_yield_expr = 48
    RULE_yield_arg = 49
    RULE_trailer = 50
    RULE_arguments = 51
    RULE_arglist = 52
    RULE_argument = 53
    RULE_subscriptlist = 54
    RULE_subscript = 55
    RULE_sliceop = 56
    RULE_comp_for = 57
    RULE_comp_iter = 58

    ruleNames =  [ "root", "single_input", "file_input", "eval_input", "stmt", 
                   "compound_stmt", "suite", "decorator", "elif_clause", 
                   "else_clause", "finally_clause", "with_item", "except_clause", 
                   "classdef", "funcdef", "typedargslist", "args", "kwargs", 
                   "def_parameters", "def_parameter", "named_parameter", 
                   "simple_stmt", "small_stmt", "testlist_star_expr", "star_expr", 
                   "assign_part", "exprlist", "import_as_names", "import_as_name", 
                   "dotted_as_names", "dotted_as_name", "test", "varargslist", 
                   "vardef_parameters", "vardef_parameter", "varargs", "varkwargs", 
                   "logical_test", "comparison", "expr", "atom", "dictorsetmaker", 
                   "testlist_comp", "testlist", "dotted_name", "name", "number", 
                   "integer", "yield_expr", "yield_arg", "trailer", "arguments", 
                   "arglist", "argument", "subscriptlist", "subscript", 
                   "sliceop", "comp_for", "comp_iter" ]

    EOF = Token.EOF
    INDENT=1
    DEDENT=2
    LINE_BREAK=3
    DEF=4
    RETURN=5
    RAISE=6
    FROM=7
    IMPORT=8
    NONLOCAL=9
    AS=10
    GLOBAL=11
    ASSERT=12
    IF=13
    ELIF=14
    ELSE=15
    WHILE=16
    FOR=17
    IN=18
    TRY=19
    NONE=20
    FINALLY=21
    WITH=22
    EXCEPT=23
    LAMBDA=24
    OR=25
    AND=26
    NOT=27
    IS=28
    CLASS=29
    YIELD=30
    DEL=31
    PASS=32
    CONTINUE=33
    BREAK=34
    ASYNC=35
    AWAIT=36
    PRINT=37
    EXEC=38
    TRUE=39
    FALSE=40
    DOT=41
    ELLIPSIS=42
    REVERSE_QUOTE=43
    STAR=44
    COMMA=45
    COLON=46
    SEMI_COLON=47
    POWER=48
    ASSIGN=49
    OR_OP=50
    XOR=51
    AND_OP=52
    LEFT_SHIFT=53
    RIGHT_SHIFT=54
    ADD=55
    MINUS=56
    DIV=57
    MOD=58
    IDIV=59
    NOT_OP=60
    LESS_THAN=61
    GREATER_THAN=62
    EQUALS=63
    GT_EQ=64
    LT_EQ=65
    NOT_EQ_1=66
    NOT_EQ_2=67
    AT=68
    ARROW=69
    ADD_ASSIGN=70
    SUB_ASSIGN=71
    MULT_ASSIGN=72
    AT_ASSIGN=73
    DIV_ASSIGN=74
    MOD_ASSIGN=75
    AND_ASSIGN=76
    OR_ASSIGN=77
    XOR_ASSIGN=78
    LEFT_SHIFT_ASSIGN=79
    RIGHT_SHIFT_ASSIGN=80
    POWER_ASSIGN=81
    IDIV_ASSIGN=82
    STRING=83
    DECIMAL_INTEGER=84
    OCT_INTEGER=85
    HEX_INTEGER=86
    BIN_INTEGER=87
    IMAG_NUMBER=88
    FLOAT_NUMBER=89
    OPEN_PAREN=90
    CLOSE_PAREN=91
    OPEN_BRACE=92
    CLOSE_BRACE=93
    OPEN_BRACKET=94
    CLOSE_BRACKET=95
    NAME=96
    LINE_JOIN=97
    NEWLINE=98
    WS=99
    COMMENT=100

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.8")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class RootContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(PythonParser.EOF, 0)

        def single_input(self):
            return self.getTypedRuleContext(PythonParser.Single_inputContext,0)


        def file_input(self):
            return self.getTypedRuleContext(PythonParser.File_inputContext,0)


        def eval_input(self):
            return self.getTypedRuleContext(PythonParser.Eval_inputContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_root

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRoot" ):
                listener.enterRoot(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRoot" ):
                listener.exitRoot(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRoot" ):
                return visitor.visitRoot(self)
            else:
                return visitor.visitChildren(self)




    def root(self):

        localctx = PythonParser.RootContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_root)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 121
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.state = 118
                self.single_input()

            elif la_ == 2:
                self.state = 119
                self.file_input()

            elif la_ == 3:
                self.state = 120
                self.eval_input()


            self.state = 123
            self.match(PythonParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Single_inputContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LINE_BREAK(self):
            return self.getToken(PythonParser.LINE_BREAK, 0)

        def simple_stmt(self):
            return self.getTypedRuleContext(PythonParser.Simple_stmtContext,0)


        def compound_stmt(self):
            return self.getTypedRuleContext(PythonParser.Compound_stmtContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_single_input

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSingle_input" ):
                listener.enterSingle_input(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSingle_input" ):
                listener.exitSingle_input(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSingle_input" ):
                return visitor.visitSingle_input(self)
            else:
                return visitor.visitChildren(self)




    def single_input(self):

        localctx = PythonParser.Single_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_single_input)
        try:
            self.state = 130
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 125
                self.match(PythonParser.LINE_BREAK)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 126
                self.simple_stmt()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 127
                self.compound_stmt()
                self.state = 128
                self.match(PythonParser.LINE_BREAK)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class File_inputContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LINE_BREAK(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.LINE_BREAK)
            else:
                return self.getToken(PythonParser.LINE_BREAK, i)

        def stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.StmtContext)
            else:
                return self.getTypedRuleContext(PythonParser.StmtContext,i)


        def getRuleIndex(self):
            return PythonParser.RULE_file_input

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFile_input" ):
                listener.enterFile_input(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFile_input" ):
                listener.exitFile_input(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFile_input" ):
                return visitor.visitFile_input(self)
            else:
                return visitor.visitChildren(self)




    def file_input(self):

        localctx = PythonParser.File_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_file_input)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 134 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 134
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
                    if la_ == 1:
                        self.state = 132
                        self.match(PythonParser.LINE_BREAK)
                        pass

                    elif la_ == 2:
                        self.state = 133
                        self.stmt()
                        pass



                else:
                    raise NoViableAltException(self)
                self.state = 136 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Eval_inputContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)


        def LINE_BREAK(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.LINE_BREAK)
            else:
                return self.getToken(PythonParser.LINE_BREAK, i)

        def getRuleIndex(self):
            return PythonParser.RULE_eval_input

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEval_input" ):
                listener.enterEval_input(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEval_input" ):
                listener.exitEval_input(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEval_input" ):
                return visitor.visitEval_input(self)
            else:
                return visitor.visitChildren(self)




    def eval_input(self):

        localctx = PythonParser.Eval_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_eval_input)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 138
            self.testlist()
            self.state = 142
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==PythonParser.LINE_BREAK:
                self.state = 139
                self.match(PythonParser.LINE_BREAK)
                self.state = 144
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_stmt(self):
            return self.getTypedRuleContext(PythonParser.Simple_stmtContext,0)


        def compound_stmt(self):
            return self.getTypedRuleContext(PythonParser.Compound_stmtContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStmt" ):
                listener.enterStmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStmt" ):
                listener.exitStmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStmt" ):
                return visitor.visitStmt(self)
            else:
                return visitor.visitChildren(self)




    def stmt(self):

        localctx = PythonParser.StmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_stmt)
        try:
            self.state = 147
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 145
                self.simple_stmt()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 146
                self.compound_stmt()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Compound_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return PythonParser.RULE_compound_stmt

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class While_stmtContext(Compound_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def WHILE(self):
            return self.getToken(PythonParser.WHILE, 0)
        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)
        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)

        def else_clause(self):
            return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWhile_stmt" ):
                listener.enterWhile_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWhile_stmt" ):
                listener.exitWhile_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhile_stmt" ):
                return visitor.visitWhile_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Try_stmtContext(Compound_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TRY(self):
            return self.getToken(PythonParser.TRY, 0)
        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)
        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)

        def finally_clause(self):
            return self.getTypedRuleContext(PythonParser.Finally_clauseContext,0)

        def except_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Except_clauseContext)
            else:
                return self.getTypedRuleContext(PythonParser.Except_clauseContext,i)

        def else_clause(self):
            return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTry_stmt" ):
                listener.enterTry_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTry_stmt" ):
                listener.exitTry_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTry_stmt" ):
                return visitor.visitTry_stmt(self)
            else:
                return visitor.visitChildren(self)


    class If_stmtContext(Compound_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
            super().__init__(parser)
            self.cond = None # TestContext
            self.copyFrom(ctx)

        def IF(self):
            return self.getToken(PythonParser.IF, 0)
        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)
        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)

        def elif_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Elif_clauseContext)
            else:
                return self.getTypedRuleContext(PythonParser.Elif_clauseContext,i)

        def else_clause(self):
            return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIf_stmt" ):
                listener.enterIf_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIf_stmt" ):
                listener.exitIf_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIf_stmt" ):
                return visitor.visitIf_stmt(self)
            else:
                return visitor.visitChildren(self)


    class With_stmtContext(Compound_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def WITH(self):
            return self.getToken(PythonParser.WITH, 0)
        def with_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.With_itemContext)
            else:
                return self.getTypedRuleContext(PythonParser.With_itemContext,i)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)
        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)

        def ASYNC(self):
            return self.getToken(PythonParser.ASYNC, 0)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWith_stmt" ):
                listener.enterWith_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWith_stmt" ):
                listener.exitWith_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWith_stmt" ):
                return visitor.visitWith_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Class_or_func_def_stmtContext(Compound_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def classdef(self):
            return self.getTypedRuleContext(PythonParser.ClassdefContext,0)

        def funcdef(self):
            return self.getTypedRuleContext(PythonParser.FuncdefContext,0)

        def decorator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.DecoratorContext)
            else:
                return self.getTypedRuleContext(PythonParser.DecoratorContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_or_func_def_stmt" ):
                listener.enterClass_or_func_def_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_or_func_def_stmt" ):
                listener.exitClass_or_func_def_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClass_or_func_def_stmt" ):
                return visitor.visitClass_or_func_def_stmt(self)
            else:
                return visitor.visitChildren(self)


    class For_stmtContext(Compound_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Compound_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def FOR(self):
            return self.getToken(PythonParser.FOR, 0)
        def exprlist(self):
            return self.getTypedRuleContext(PythonParser.ExprlistContext,0)

        def IN(self):
            return self.getToken(PythonParser.IN, 0)
        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)
        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)

        def ASYNC(self):
            return self.getToken(PythonParser.ASYNC, 0)
        def else_clause(self):
            return self.getTypedRuleContext(PythonParser.Else_clauseContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFor_stmt" ):
                listener.enterFor_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFor_stmt" ):
                listener.exitFor_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFor_stmt" ):
                return visitor.visitFor_stmt(self)
            else:
                return visitor.visitChildren(self)



    def compound_stmt(self):

        localctx = PythonParser.Compound_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_compound_stmt)
        self._la = 0 # Token type
        try:
            self.state = 223
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                localctx = PythonParser.If_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 149
                self.match(PythonParser.IF)
                self.state = 150
                localctx.cond = self.test()
                self.state = 151
                self.match(PythonParser.COLON)
                self.state = 152
                self.suite()
                self.state = 156
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 153
                        self.elif_clause() 
                    self.state = 158
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,6,self._ctx)

                self.state = 160
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                if la_ == 1:
                    self.state = 159
                    self.else_clause()


                pass

            elif la_ == 2:
                localctx = PythonParser.While_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 162
                self.match(PythonParser.WHILE)
                self.state = 163
                self.test()
                self.state = 164
                self.match(PythonParser.COLON)
                self.state = 165
                self.suite()
                self.state = 167
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
                if la_ == 1:
                    self.state = 166
                    self.else_clause()


                pass

            elif la_ == 3:
                localctx = PythonParser.For_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 170
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.ASYNC:
                    self.state = 169
                    self.match(PythonParser.ASYNC)


                self.state = 172
                self.match(PythonParser.FOR)
                self.state = 173
                self.exprlist()
                self.state = 174
                self.match(PythonParser.IN)
                self.state = 175
                self.testlist()
                self.state = 176
                self.match(PythonParser.COLON)
                self.state = 177
                self.suite()
                self.state = 179
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
                if la_ == 1:
                    self.state = 178
                    self.else_clause()


                pass

            elif la_ == 4:
                localctx = PythonParser.Try_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 181
                self.match(PythonParser.TRY)
                self.state = 182
                self.match(PythonParser.COLON)
                self.state = 183
                self.suite()
                self.state = 196
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.EXCEPT]:
                    self.state = 185 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 184
                            self.except_clause()

                        else:
                            raise NoViableAltException(self)
                        self.state = 187 
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

                    self.state = 190
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                    if la_ == 1:
                        self.state = 189
                        self.else_clause()


                    self.state = 193
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
                    if la_ == 1:
                        self.state = 192
                        self.finally_clause()


                    pass
                elif token in [PythonParser.FINALLY]:
                    self.state = 195
                    self.finally_clause()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 5:
                localctx = PythonParser.With_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 199
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.ASYNC:
                    self.state = 198
                    self.match(PythonParser.ASYNC)


                self.state = 201
                self.match(PythonParser.WITH)
                self.state = 202
                self.with_item()
                self.state = 207
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==PythonParser.COMMA:
                    self.state = 203
                    self.match(PythonParser.COMMA)
                    self.state = 204
                    self.with_item()
                    self.state = 209
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 210
                self.match(PythonParser.COLON)
                self.state = 211
                self.suite()
                pass

            elif la_ == 6:
                localctx = PythonParser.Class_or_func_def_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 216
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==PythonParser.AT:
                    self.state = 213
                    self.decorator()
                    self.state = 218
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 221
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.CLASS]:
                    self.state = 219
                    self.classdef()
                    pass
                elif token in [PythonParser.DEF, PythonParser.ASYNC]:
                    self.state = 220
                    self.funcdef()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SuiteContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def simple_stmt(self):
            return self.getTypedRuleContext(PythonParser.Simple_stmtContext,0)


        def LINE_BREAK(self):
            return self.getToken(PythonParser.LINE_BREAK, 0)

        def INDENT(self):
            return self.getToken(PythonParser.INDENT, 0)

        def DEDENT(self):
            return self.getToken(PythonParser.DEDENT, 0)

        def stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.StmtContext)
            else:
                return self.getTypedRuleContext(PythonParser.StmtContext,i)


        def getRuleIndex(self):
            return PythonParser.RULE_suite

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSuite" ):
                listener.enterSuite(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSuite" ):
                listener.exitSuite(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSuite" ):
                return visitor.visitSuite(self)
            else:
                return visitor.visitChildren(self)




    def suite(self):

        localctx = PythonParser.SuiteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_suite)
        try:
            self.state = 235
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 225
                self.simple_stmt()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 226
                self.match(PythonParser.LINE_BREAK)
                self.state = 227
                self.match(PythonParser.INDENT)
                self.state = 229 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 228
                        self.stmt()

                    else:
                        raise NoViableAltException(self)
                    self.state = 231 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,20,self._ctx)

                self.state = 233
                self.match(PythonParser.DEDENT)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DecoratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AT(self):
            return self.getToken(PythonParser.AT, 0)

        def dotted_name(self):
            return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)


        def LINE_BREAK(self):
            return self.getToken(PythonParser.LINE_BREAK, 0)

        def OPEN_PAREN(self):
            return self.getToken(PythonParser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(PythonParser.CLOSE_PAREN, 0)

        def arglist(self):
            return self.getTypedRuleContext(PythonParser.ArglistContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_decorator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDecorator" ):
                listener.enterDecorator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDecorator" ):
                listener.exitDecorator(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDecorator" ):
                return visitor.visitDecorator(self)
            else:
                return visitor.visitChildren(self)




    def decorator(self):

        localctx = PythonParser.DecoratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_decorator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 237
            self.match(PythonParser.AT)
            self.state = 238
            self.dotted_name(0)
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.OPEN_PAREN:
                self.state = 239
                self.match(PythonParser.OPEN_PAREN)
                self.state = 241
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 240
                    self.arglist()


                self.state = 243
                self.match(PythonParser.CLOSE_PAREN)


            self.state = 246
            self.match(PythonParser.LINE_BREAK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Elif_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ELIF(self):
            return self.getToken(PythonParser.ELIF, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_elif_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElif_clause" ):
                listener.enterElif_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElif_clause" ):
                listener.exitElif_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElif_clause" ):
                return visitor.visitElif_clause(self)
            else:
                return visitor.visitChildren(self)




    def elif_clause(self):

        localctx = PythonParser.Elif_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_elif_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.match(PythonParser.ELIF)
            self.state = 249
            self.test()
            self.state = 250
            self.match(PythonParser.COLON)
            self.state = 251
            self.suite()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Else_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ELSE(self):
            return self.getToken(PythonParser.ELSE, 0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_else_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElse_clause" ):
                listener.enterElse_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElse_clause" ):
                listener.exitElse_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitElse_clause" ):
                return visitor.visitElse_clause(self)
            else:
                return visitor.visitChildren(self)




    def else_clause(self):

        localctx = PythonParser.Else_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_else_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 253
            self.match(PythonParser.ELSE)
            self.state = 254
            self.match(PythonParser.COLON)
            self.state = 255
            self.suite()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Finally_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FINALLY(self):
            return self.getToken(PythonParser.FINALLY, 0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_finally_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFinally_clause" ):
                listener.enterFinally_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFinally_clause" ):
                listener.exitFinally_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFinally_clause" ):
                return visitor.visitFinally_clause(self)
            else:
                return visitor.visitChildren(self)




    def finally_clause(self):

        localctx = PythonParser.Finally_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_finally_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 257
            self.match(PythonParser.FINALLY)
            self.state = 258
            self.match(PythonParser.COLON)
            self.state = 259
            self.suite()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class With_itemContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def AS(self):
            return self.getToken(PythonParser.AS, 0)

        def expr(self):
            return self.getTypedRuleContext(PythonParser.ExprContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_with_item

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWith_item" ):
                listener.enterWith_item(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWith_item" ):
                listener.exitWith_item(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWith_item" ):
                return visitor.visitWith_item(self)
            else:
                return visitor.visitChildren(self)




    def with_item(self):

        localctx = PythonParser.With_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_with_item)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 261
            self.test()
            self.state = 264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.AS:
                self.state = 262
                self.match(PythonParser.AS)
                self.state = 263
                self.expr(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Except_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXCEPT(self):
            return self.getToken(PythonParser.EXCEPT, 0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)


        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def COMMA(self):
            return self.getToken(PythonParser.COMMA, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def AS(self):
            return self.getToken(PythonParser.AS, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_except_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExcept_clause" ):
                listener.enterExcept_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExcept_clause" ):
                listener.exitExcept_clause(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExcept_clause" ):
                return visitor.visitExcept_clause(self)
            else:
                return visitor.visitChildren(self)




    def except_clause(self):

        localctx = PythonParser.Except_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_except_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 266
            self.match(PythonParser.EXCEPT)
            self.state = 280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                self.state = 267
                self.test()
                self.state = 278
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
                if la_ == 1:
                    self.state = 268
                    if not self.CheckVersion(2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.CheckVersion(2)")
                    self.state = 269
                    self.match(PythonParser.COMMA)
                    self.state = 270
                    self.name()
                    self.SetVersion(2);

                elif la_ == 2:
                    self.state = 273
                    if not self.CheckVersion(3):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.CheckVersion(3)")
                    self.state = 274
                    self.match(PythonParser.AS)
                    self.state = 275
                    self.name()
                    self.SetVersion(3);




            self.state = 282
            self.match(PythonParser.COLON)
            self.state = 283
            self.suite()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassdefContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CLASS(self):
            return self.getToken(PythonParser.CLASS, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)


        def OPEN_PAREN(self):
            return self.getToken(PythonParser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(PythonParser.CLOSE_PAREN, 0)

        def arglist(self):
            return self.getTypedRuleContext(PythonParser.ArglistContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_classdef

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClassdef" ):
                listener.enterClassdef(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClassdef" ):
                listener.exitClassdef(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitClassdef" ):
                return visitor.visitClassdef(self)
            else:
                return visitor.visitChildren(self)




    def classdef(self):

        localctx = PythonParser.ClassdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_classdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 285
            self.match(PythonParser.CLASS)
            self.state = 286
            self.name()
            self.state = 292
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.OPEN_PAREN:
                self.state = 287
                self.match(PythonParser.OPEN_PAREN)
                self.state = 289
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 288
                    self.arglist()


                self.state = 291
                self.match(PythonParser.CLOSE_PAREN)


            self.state = 294
            self.match(PythonParser.COLON)
            self.state = 295
            self.suite()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FuncdefContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DEF(self):
            return self.getToken(PythonParser.DEF, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def OPEN_PAREN(self):
            return self.getToken(PythonParser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(PythonParser.CLOSE_PAREN, 0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def suite(self):
            return self.getTypedRuleContext(PythonParser.SuiteContext,0)


        def ASYNC(self):
            return self.getToken(PythonParser.ASYNC, 0)

        def typedargslist(self):
            return self.getTypedRuleContext(PythonParser.TypedargslistContext,0)


        def ARROW(self):
            return self.getToken(PythonParser.ARROW, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_funcdef

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFuncdef" ):
                listener.enterFuncdef(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFuncdef" ):
                listener.exitFuncdef(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFuncdef" ):
                return visitor.visitFuncdef(self)
            else:
                return visitor.visitChildren(self)




    def funcdef(self):

        localctx = PythonParser.FuncdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_funcdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.ASYNC:
                self.state = 297
                self.match(PythonParser.ASYNC)


            self.state = 300
            self.match(PythonParser.DEF)
            self.state = 301
            self.name()
            self.state = 302
            self.match(PythonParser.OPEN_PAREN)
            self.state = 304
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (PythonParser.TRUE - 39)) | (1 << (PythonParser.FALSE - 39)) | (1 << (PythonParser.STAR - 39)) | (1 << (PythonParser.POWER - 39)) | (1 << (PythonParser.NAME - 39)))) != 0):
                self.state = 303
                self.typedargslist()


            self.state = 306
            self.match(PythonParser.CLOSE_PAREN)
            self.state = 309
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.ARROW:
                self.state = 307
                self.match(PythonParser.ARROW)
                self.state = 308
                self.test()


            self.state = 311
            self.match(PythonParser.COLON)
            self.state = 312
            self.suite()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TypedargslistContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def args(self):
            return self.getTypedRuleContext(PythonParser.ArgsContext,0)


        def kwargs(self):
            return self.getTypedRuleContext(PythonParser.KwargsContext,0)


        def def_parameters(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Def_parametersContext)
            else:
                return self.getTypedRuleContext(PythonParser.Def_parametersContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_typedargslist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTypedargslist" ):
                listener.enterTypedargslist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTypedargslist" ):
                listener.exitTypedargslist(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTypedargslist" ):
                return visitor.visitTypedargslist(self)
            else:
                return visitor.visitChildren(self)




    def typedargslist(self):

        localctx = PythonParser.TypedargslistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_typedargslist)
        self._la = 0 # Token type
        try:
            self.state = 338
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
                if la_ == 1:
                    self.state = 314
                    self.def_parameters()
                    self.state = 315
                    self.match(PythonParser.COMMA)


                self.state = 329
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.STAR]:
                    self.state = 319
                    self.args()
                    self.state = 322
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
                    if la_ == 1:
                        self.state = 320
                        self.match(PythonParser.COMMA)
                        self.state = 321
                        self.def_parameters()


                    self.state = 326
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                    if la_ == 1:
                        self.state = 324
                        self.match(PythonParser.COMMA)
                        self.state = 325
                        self.kwargs()


                    pass
                elif token in [PythonParser.POWER]:
                    self.state = 328
                    self.kwargs()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 332
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 331
                    self.match(PythonParser.COMMA)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 334
                self.def_parameters()
                self.state = 336
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 335
                    self.match(PythonParser.COMMA)


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def named_parameter(self):
            return self.getTypedRuleContext(PythonParser.Named_parameterContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_args

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArgs" ):
                listener.enterArgs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArgs" ):
                listener.exitArgs(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgs" ):
                return visitor.visitArgs(self)
            else:
                return visitor.visitChildren(self)




    def args(self):

        localctx = PythonParser.ArgsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_args)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 340
            self.match(PythonParser.STAR)
            self.state = 341
            self.named_parameter()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class KwargsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def POWER(self):
            return self.getToken(PythonParser.POWER, 0)

        def named_parameter(self):
            return self.getTypedRuleContext(PythonParser.Named_parameterContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_kwargs

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterKwargs" ):
                listener.enterKwargs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitKwargs" ):
                listener.exitKwargs(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitKwargs" ):
                return visitor.visitKwargs(self)
            else:
                return visitor.visitChildren(self)




    def kwargs(self):

        localctx = PythonParser.KwargsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_kwargs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 343
            self.match(PythonParser.POWER)
            self.state = 344
            self.named_parameter()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Def_parametersContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def def_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Def_parameterContext)
            else:
                return self.getTypedRuleContext(PythonParser.Def_parameterContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_def_parameters

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDef_parameters" ):
                listener.enterDef_parameters(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDef_parameters" ):
                listener.exitDef_parameters(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDef_parameters" ):
                return visitor.visitDef_parameters(self)
            else:
                return visitor.visitChildren(self)




    def def_parameters(self):

        localctx = PythonParser.Def_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_def_parameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 346
            self.def_parameter()
            self.state = 351
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,39,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 347
                    self.match(PythonParser.COMMA)
                    self.state = 348
                    self.def_parameter() 
                self.state = 353
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,39,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Def_parameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def named_parameter(self):
            return self.getTypedRuleContext(PythonParser.Named_parameterContext,0)


        def ASSIGN(self):
            return self.getToken(PythonParser.ASSIGN, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_def_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDef_parameter" ):
                listener.enterDef_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDef_parameter" ):
                listener.exitDef_parameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDef_parameter" ):
                return visitor.visitDef_parameter(self)
            else:
                return visitor.visitChildren(self)




    def def_parameter(self):

        localctx = PythonParser.Def_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_def_parameter)
        self._la = 0 # Token type
        try:
            self.state = 360
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 354
                self.named_parameter()
                self.state = 357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.ASSIGN:
                    self.state = 355
                    self.match(PythonParser.ASSIGN)
                    self.state = 356
                    self.test()


                pass
            elif token in [PythonParser.STAR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 359
                self.match(PythonParser.STAR)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Named_parameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_named_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamed_parameter" ):
                listener.enterNamed_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamed_parameter" ):
                listener.exitNamed_parameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNamed_parameter" ):
                return visitor.visitNamed_parameter(self)
            else:
                return visitor.visitChildren(self)




    def named_parameter(self):

        localctx = PythonParser.Named_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_named_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 362
            self.name()
            self.state = 365
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.COLON:
                self.state = 363
                self.match(PythonParser.COLON)
                self.state = 364
                self.test()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def small_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Small_stmtContext)
            else:
                return self.getTypedRuleContext(PythonParser.Small_stmtContext,i)


        def LINE_BREAK(self):
            return self.getToken(PythonParser.LINE_BREAK, 0)

        def EOF(self):
            return self.getToken(PythonParser.EOF, 0)

        def SEMI_COLON(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.SEMI_COLON)
            else:
                return self.getToken(PythonParser.SEMI_COLON, i)

        def getRuleIndex(self):
            return PythonParser.RULE_simple_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimple_stmt" ):
                listener.enterSimple_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimple_stmt" ):
                listener.exitSimple_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSimple_stmt" ):
                return visitor.visitSimple_stmt(self)
            else:
                return visitor.visitChildren(self)




    def simple_stmt(self):

        localctx = PythonParser.Simple_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_simple_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 367
            self.small_stmt()
            self.state = 372
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,43,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 368
                    self.match(PythonParser.SEMI_COLON)
                    self.state = 369
                    self.small_stmt() 
                self.state = 374
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,43,self._ctx)

            self.state = 376
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.SEMI_COLON:
                self.state = 375
                self.match(PythonParser.SEMI_COLON)


            self.state = 378
            _la = self._input.LA(1)
            if not(_la==PythonParser.EOF or _la==PythonParser.LINE_BREAK):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Small_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return PythonParser.RULE_small_stmt

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class Assert_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ASSERT(self):
            return self.getToken(PythonParser.ASSERT, 0)
        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)

        def COMMA(self):
            return self.getToken(PythonParser.COMMA, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssert_stmt" ):
                listener.enterAssert_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssert_stmt" ):
                listener.exitAssert_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssert_stmt" ):
                return visitor.visitAssert_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Nonlocal_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NONLOCAL(self):
            return self.getToken(PythonParser.NONLOCAL, 0)
        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.NameContext)
            else:
                return self.getTypedRuleContext(PythonParser.NameContext,i)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNonlocal_stmt" ):
                listener.enterNonlocal_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNonlocal_stmt" ):
                listener.exitNonlocal_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNonlocal_stmt" ):
                return visitor.visitNonlocal_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Pass_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def PASS(self):
            return self.getToken(PythonParser.PASS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPass_stmt" ):
                listener.enterPass_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPass_stmt" ):
                listener.exitPass_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPass_stmt" ):
                return visitor.visitPass_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Import_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IMPORT(self):
            return self.getToken(PythonParser.IMPORT, 0)
        def dotted_as_names(self):
            return self.getTypedRuleContext(PythonParser.Dotted_as_namesContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImport_stmt" ):
                listener.enterImport_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImport_stmt" ):
                listener.exitImport_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImport_stmt" ):
                return visitor.visitImport_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Expr_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def testlist_star_expr(self):
            return self.getTypedRuleContext(PythonParser.Testlist_star_exprContext,0)

        def assign_part(self):
            return self.getTypedRuleContext(PythonParser.Assign_partContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpr_stmt" ):
                listener.enterExpr_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpr_stmt" ):
                listener.exitExpr_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpr_stmt" ):
                return visitor.visitExpr_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Raise_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def RAISE(self):
            return self.getToken(PythonParser.RAISE, 0)
        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)

        def FROM(self):
            return self.getToken(PythonParser.FROM, 0)
        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRaise_stmt" ):
                listener.enterRaise_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRaise_stmt" ):
                listener.exitRaise_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRaise_stmt" ):
                return visitor.visitRaise_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Yield_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def yield_expr(self):
            return self.getTypedRuleContext(PythonParser.Yield_exprContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterYield_stmt" ):
                listener.enterYield_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitYield_stmt" ):
                listener.exitYield_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitYield_stmt" ):
                return visitor.visitYield_stmt(self)
            else:
                return visitor.visitChildren(self)


    class From_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def FROM(self):
            return self.getToken(PythonParser.FROM, 0)
        def IMPORT(self):
            return self.getToken(PythonParser.IMPORT, 0)
        def dotted_name(self):
            return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)

        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)
        def OPEN_PAREN(self):
            return self.getToken(PythonParser.OPEN_PAREN, 0)
        def import_as_names(self):
            return self.getTypedRuleContext(PythonParser.Import_as_namesContext,0)

        def CLOSE_PAREN(self):
            return self.getToken(PythonParser.CLOSE_PAREN, 0)
        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.DOT)
            else:
                return self.getToken(PythonParser.DOT, i)
        def ELLIPSIS(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.ELLIPSIS)
            else:
                return self.getToken(PythonParser.ELLIPSIS, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFrom_stmt" ):
                listener.enterFrom_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFrom_stmt" ):
                listener.exitFrom_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFrom_stmt" ):
                return visitor.visitFrom_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Global_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def GLOBAL(self):
            return self.getToken(PythonParser.GLOBAL, 0)
        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.NameContext)
            else:
                return self.getTypedRuleContext(PythonParser.NameContext,i)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_stmt" ):
                listener.enterGlobal_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_stmt" ):
                listener.exitGlobal_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGlobal_stmt" ):
                return visitor.visitGlobal_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Continue_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CONTINUE(self):
            return self.getToken(PythonParser.CONTINUE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterContinue_stmt" ):
                listener.enterContinue_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitContinue_stmt" ):
                listener.exitContinue_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitContinue_stmt" ):
                return visitor.visitContinue_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Exec_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def EXEC(self):
            return self.getToken(PythonParser.EXEC, 0)
        def expr(self):
            return self.getTypedRuleContext(PythonParser.ExprContext,0)

        def IN(self):
            return self.getToken(PythonParser.IN, 0)
        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)

        def COMMA(self):
            return self.getToken(PythonParser.COMMA, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExec_stmt" ):
                listener.enterExec_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExec_stmt" ):
                listener.exitExec_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExec_stmt" ):
                return visitor.visitExec_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Break_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def BREAK(self):
            return self.getToken(PythonParser.BREAK, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBreak_stmt" ):
                listener.enterBreak_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBreak_stmt" ):
                listener.exitBreak_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBreak_stmt" ):
                return visitor.visitBreak_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Del_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def DEL(self):
            return self.getToken(PythonParser.DEL, 0)
        def exprlist(self):
            return self.getTypedRuleContext(PythonParser.ExprlistContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDel_stmt" ):
                listener.enterDel_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDel_stmt" ):
                listener.exitDel_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDel_stmt" ):
                return visitor.visitDel_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Print_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def PRINT(self):
            return self.getToken(PythonParser.PRINT, 0)
        def RIGHT_SHIFT(self):
            return self.getToken(PythonParser.RIGHT_SHIFT, 0)
        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrint_stmt" ):
                listener.enterPrint_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrint_stmt" ):
                listener.exitPrint_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrint_stmt" ):
                return visitor.visitPrint_stmt(self)
            else:
                return visitor.visitChildren(self)


    class Return_stmtContext(Small_stmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a PythonParser.Small_stmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def RETURN(self):
            return self.getToken(PythonParser.RETURN, 0)
        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturn_stmt" ):
                listener.enterReturn_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturn_stmt" ):
                listener.exitReturn_stmt(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturn_stmt" ):
                return visitor.visitReturn_stmt(self)
            else:
                return visitor.visitChildren(self)



    def small_stmt(self):

        localctx = PythonParser.Small_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_small_stmt)
        self._la = 0 # Token type
        try:
            self.state = 504
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                localctx = PythonParser.Expr_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 380
                self.testlist_star_expr()
                self.state = 382
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
                if la_ == 1:
                    self.state = 381
                    self.assign_part()


                pass

            elif la_ == 2:
                localctx = PythonParser.Print_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 384
                if not self.CheckVersion(2):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.CheckVersion(2)")
                self.state = 385
                self.match(PythonParser.PRINT)
                self.state = 408
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                    self.state = 386
                    self.test()
                    self.state = 391
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,46,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 387
                            self.match(PythonParser.COMMA)
                            self.state = 388
                            self.test() 
                        self.state = 393
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,46,self._ctx)

                    self.state = 395
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==PythonParser.COMMA:
                        self.state = 394
                        self.match(PythonParser.COMMA)


                    pass
                elif token in [PythonParser.RIGHT_SHIFT]:
                    self.state = 397
                    self.match(PythonParser.RIGHT_SHIFT)
                    self.state = 398
                    self.test()

                    self.state = 401 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 399
                            self.match(PythonParser.COMMA)
                            self.state = 400
                            self.test()

                        else:
                            raise NoViableAltException(self)
                        self.state = 403 
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,48,self._ctx)

                    self.state = 406
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==PythonParser.COMMA:
                        self.state = 405
                        self.match(PythonParser.COMMA)


                    pass
                else:
                    raise NoViableAltException(self)

                self.SetVersion(2);
                pass

            elif la_ == 3:
                localctx = PythonParser.Del_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 412
                self.match(PythonParser.DEL)
                self.state = 413
                self.exprlist()
                pass

            elif la_ == 4:
                localctx = PythonParser.Pass_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 414
                self.match(PythonParser.PASS)
                pass

            elif la_ == 5:
                localctx = PythonParser.Break_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 415
                self.match(PythonParser.BREAK)
                pass

            elif la_ == 6:
                localctx = PythonParser.Continue_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 416
                self.match(PythonParser.CONTINUE)
                pass

            elif la_ == 7:
                localctx = PythonParser.Return_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 417
                self.match(PythonParser.RETURN)
                self.state = 419
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 418
                    self.testlist()


                pass

            elif la_ == 8:
                localctx = PythonParser.Raise_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 421
                self.match(PythonParser.RAISE)
                self.state = 431
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 422
                    self.test()
                    self.state = 429
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==PythonParser.COMMA:
                        self.state = 423
                        self.match(PythonParser.COMMA)
                        self.state = 424
                        self.test()
                        self.state = 427
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==PythonParser.COMMA:
                            self.state = 425
                            self.match(PythonParser.COMMA)
                            self.state = 426
                            self.test()






                self.state = 435
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.FROM:
                    self.state = 433
                    self.match(PythonParser.FROM)
                    self.state = 434
                    self.test()


                pass

            elif la_ == 9:
                localctx = PythonParser.Yield_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 437
                self.yield_expr()
                pass

            elif la_ == 10:
                localctx = PythonParser.Import_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 438
                self.match(PythonParser.IMPORT)
                self.state = 439
                self.dotted_as_names()
                pass

            elif la_ == 11:
                localctx = PythonParser.From_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 440
                self.match(PythonParser.FROM)
                self.state = 453
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
                if la_ == 1:
                    self.state = 444
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==PythonParser.DOT or _la==PythonParser.ELLIPSIS:
                        self.state = 441
                        _la = self._input.LA(1)
                        if not(_la==PythonParser.DOT or _la==PythonParser.ELLIPSIS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 446
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 447
                    self.dotted_name(0)
                    pass

                elif la_ == 2:
                    self.state = 449 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 448
                        _la = self._input.LA(1)
                        if not(_la==PythonParser.DOT or _la==PythonParser.ELLIPSIS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 451 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==PythonParser.DOT or _la==PythonParser.ELLIPSIS):
                            break

                    pass


                self.state = 455
                self.match(PythonParser.IMPORT)
                self.state = 462
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.STAR]:
                    self.state = 456
                    self.match(PythonParser.STAR)
                    pass
                elif token in [PythonParser.OPEN_PAREN]:
                    self.state = 457
                    self.match(PythonParser.OPEN_PAREN)
                    self.state = 458
                    self.import_as_names()
                    self.state = 459
                    self.match(PythonParser.CLOSE_PAREN)
                    pass
                elif token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
                    self.state = 461
                    self.import_as_names()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 12:
                localctx = PythonParser.Global_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 464
                self.match(PythonParser.GLOBAL)
                self.state = 465
                self.name()
                self.state = 470
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==PythonParser.COMMA:
                    self.state = 466
                    self.match(PythonParser.COMMA)
                    self.state = 467
                    self.name()
                    self.state = 472
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 13:
                localctx = PythonParser.Exec_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 473
                if not self.CheckVersion(2):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.CheckVersion(2)")
                self.state = 474
                self.match(PythonParser.EXEC)
                self.state = 475
                self.expr(0)
                self.state = 482
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.IN:
                    self.state = 476
                    self.match(PythonParser.IN)
                    self.state = 477
                    self.test()
                    self.state = 480
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==PythonParser.COMMA:
                        self.state = 478
                        self.match(PythonParser.COMMA)
                        self.state = 479
                        self.test()




                self.SetVersion(2);
                pass

            elif la_ == 14:
                localctx = PythonParser.Assert_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 486
                self.match(PythonParser.ASSERT)
                self.state = 487
                self.test()
                self.state = 490
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 488
                    self.match(PythonParser.COMMA)
                    self.state = 489
                    self.test()


                pass

            elif la_ == 15:
                localctx = PythonParser.Nonlocal_stmtContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 492
                if not self.CheckVersion(3):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.CheckVersion(3)")
                self.state = 493
                self.match(PythonParser.NONLOCAL)
                self.state = 494
                self.name()
                self.state = 499
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==PythonParser.COMMA:
                    self.state = 495
                    self.match(PythonParser.COMMA)
                    self.state = 496
                    self.name()
                    self.state = 501
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.SetVersion(3);
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Testlist_star_exprContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)


        def star_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Star_exprContext)
            else:
                return self.getTypedRuleContext(PythonParser.Star_exprContext,i)


        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_testlist_star_expr

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTestlist_star_expr" ):
                listener.enterTestlist_star_expr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTestlist_star_expr" ):
                listener.exitTestlist_star_expr(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTestlist_star_expr" ):
                return visitor.visitTestlist_star_expr(self)
            else:
                return visitor.visitChildren(self)




    def testlist_star_expr(self):

        localctx = PythonParser.Testlist_star_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_testlist_star_expr)
        try:
            self.state = 521
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 512 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 508
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                            self.state = 506
                            self.test()
                            pass
                        elif token in [PythonParser.STAR]:
                            self.state = 507
                            self.star_expr()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 510
                        self.match(PythonParser.COMMA)

                    else:
                        raise NoViableAltException(self)
                    self.state = 514 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,67,self._ctx)

                self.state = 518
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 516
                    self.test()

                elif la_ == 2:
                    self.state = 517
                    self.star_expr()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 520
                self.testlist()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Star_exprContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def expr(self):
            return self.getTypedRuleContext(PythonParser.ExprContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_star_expr

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStar_expr" ):
                listener.enterStar_expr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStar_expr" ):
                listener.exitStar_expr(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStar_expr" ):
                return visitor.visitStar_expr(self)
            else:
                return visitor.visitChildren(self)




    def star_expr(self):

        localctx = PythonParser.Star_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_star_expr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 523
            self.match(PythonParser.STAR)
            self.state = 524
            self.expr(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Assign_partContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.op = None # Token

        def ASSIGN(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.ASSIGN)
            else:
                return self.getToken(PythonParser.ASSIGN, i)

        def testlist_star_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Testlist_star_exprContext)
            else:
                return self.getTypedRuleContext(PythonParser.Testlist_star_exprContext,i)


        def yield_expr(self):
            return self.getTypedRuleContext(PythonParser.Yield_exprContext,0)


        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)


        def ADD_ASSIGN(self):
            return self.getToken(PythonParser.ADD_ASSIGN, 0)

        def SUB_ASSIGN(self):
            return self.getToken(PythonParser.SUB_ASSIGN, 0)

        def MULT_ASSIGN(self):
            return self.getToken(PythonParser.MULT_ASSIGN, 0)

        def AT_ASSIGN(self):
            return self.getToken(PythonParser.AT_ASSIGN, 0)

        def DIV_ASSIGN(self):
            return self.getToken(PythonParser.DIV_ASSIGN, 0)

        def MOD_ASSIGN(self):
            return self.getToken(PythonParser.MOD_ASSIGN, 0)

        def AND_ASSIGN(self):
            return self.getToken(PythonParser.AND_ASSIGN, 0)

        def OR_ASSIGN(self):
            return self.getToken(PythonParser.OR_ASSIGN, 0)

        def XOR_ASSIGN(self):
            return self.getToken(PythonParser.XOR_ASSIGN, 0)

        def LEFT_SHIFT_ASSIGN(self):
            return self.getToken(PythonParser.LEFT_SHIFT_ASSIGN, 0)

        def RIGHT_SHIFT_ASSIGN(self):
            return self.getToken(PythonParser.RIGHT_SHIFT_ASSIGN, 0)

        def POWER_ASSIGN(self):
            return self.getToken(PythonParser.POWER_ASSIGN, 0)

        def IDIV_ASSIGN(self):
            return self.getToken(PythonParser.IDIV_ASSIGN, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_assign_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssign_part" ):
                listener.enterAssign_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssign_part" ):
                listener.exitAssign_part(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssign_part" ):
                return visitor.visitAssign_part(self)
            else:
                return visitor.visitChildren(self)




    def assign_part(self):

        localctx = PythonParser.Assign_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_assign_part)
        self._la = 0 # Token type
        try:
            self.state = 556
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 526
                self.match(PythonParser.ASSIGN)
                self.state = 540
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.STAR, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                    self.state = 527
                    self.testlist_star_expr()
                    self.state = 532
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,70,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 528
                            self.match(PythonParser.ASSIGN)
                            self.state = 529
                            self.testlist_star_expr() 
                        self.state = 534
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,70,self._ctx)

                    self.state = 537
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==PythonParser.ASSIGN:
                        self.state = 535
                        self.match(PythonParser.ASSIGN)
                        self.state = 536
                        self.yield_expr()


                    pass
                elif token in [PythonParser.YIELD]:
                    self.state = 539
                    self.yield_expr()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 542
                if not self.CheckVersion(3):
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, "self.CheckVersion(3)")
                self.state = 543
                self.match(PythonParser.COLON)
                self.state = 544
                self.test()
                self.state = 547
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.ASSIGN:
                    self.state = 545
                    self.match(PythonParser.ASSIGN)
                    self.state = 546
                    self.testlist()


                self.SetVersion(3);
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 551
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not(((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & ((1 << (PythonParser.ADD_ASSIGN - 70)) | (1 << (PythonParser.SUB_ASSIGN - 70)) | (1 << (PythonParser.MULT_ASSIGN - 70)) | (1 << (PythonParser.AT_ASSIGN - 70)) | (1 << (PythonParser.DIV_ASSIGN - 70)) | (1 << (PythonParser.MOD_ASSIGN - 70)) | (1 << (PythonParser.AND_ASSIGN - 70)) | (1 << (PythonParser.OR_ASSIGN - 70)) | (1 << (PythonParser.XOR_ASSIGN - 70)) | (1 << (PythonParser.LEFT_SHIFT_ASSIGN - 70)) | (1 << (PythonParser.RIGHT_SHIFT_ASSIGN - 70)) | (1 << (PythonParser.POWER_ASSIGN - 70)) | (1 << (PythonParser.IDIV_ASSIGN - 70)))) != 0)):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 554
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.YIELD]:
                    self.state = 552
                    self.yield_expr()
                    pass
                elif token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                    self.state = 553
                    self.testlist()
                    pass
                else:
                    raise NoViableAltException(self)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExprlistContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.ExprContext)
            else:
                return self.getTypedRuleContext(PythonParser.ExprContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_exprlist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExprlist" ):
                listener.enterExprlist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExprlist" ):
                listener.exitExprlist(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExprlist" ):
                return visitor.visitExprlist(self)
            else:
                return visitor.visitChildren(self)




    def exprlist(self):

        localctx = PythonParser.ExprlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_exprlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 558
            self.expr(0)
            self.state = 563
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,76,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 559
                    self.match(PythonParser.COMMA)
                    self.state = 560
                    self.expr(0) 
                self.state = 565
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,76,self._ctx)

            self.state = 567
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.COMMA:
                self.state = 566
                self.match(PythonParser.COMMA)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Import_as_namesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def import_as_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Import_as_nameContext)
            else:
                return self.getTypedRuleContext(PythonParser.Import_as_nameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_import_as_names

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImport_as_names" ):
                listener.enterImport_as_names(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImport_as_names" ):
                listener.exitImport_as_names(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImport_as_names" ):
                return visitor.visitImport_as_names(self)
            else:
                return visitor.visitChildren(self)




    def import_as_names(self):

        localctx = PythonParser.Import_as_namesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_import_as_names)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 569
            self.import_as_name()
            self.state = 574
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,78,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 570
                    self.match(PythonParser.COMMA)
                    self.state = 571
                    self.import_as_name() 
                self.state = 576
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,78,self._ctx)

            self.state = 578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.COMMA:
                self.state = 577
                self.match(PythonParser.COMMA)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Import_as_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.NameContext)
            else:
                return self.getTypedRuleContext(PythonParser.NameContext,i)


        def AS(self):
            return self.getToken(PythonParser.AS, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_import_as_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterImport_as_name" ):
                listener.enterImport_as_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitImport_as_name" ):
                listener.exitImport_as_name(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitImport_as_name" ):
                return visitor.visitImport_as_name(self)
            else:
                return visitor.visitChildren(self)




    def import_as_name(self):

        localctx = PythonParser.Import_as_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_import_as_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 580
            self.name()
            self.state = 583
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.AS:
                self.state = 581
                self.match(PythonParser.AS)
                self.state = 582
                self.name()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dotted_as_namesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dotted_as_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Dotted_as_nameContext)
            else:
                return self.getTypedRuleContext(PythonParser.Dotted_as_nameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_dotted_as_names

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDotted_as_names" ):
                listener.enterDotted_as_names(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDotted_as_names" ):
                listener.exitDotted_as_names(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDotted_as_names" ):
                return visitor.visitDotted_as_names(self)
            else:
                return visitor.visitChildren(self)




    def dotted_as_names(self):

        localctx = PythonParser.Dotted_as_namesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_dotted_as_names)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 585
            self.dotted_as_name()
            self.state = 590
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==PythonParser.COMMA:
                self.state = 586
                self.match(PythonParser.COMMA)
                self.state = 587
                self.dotted_as_name()
                self.state = 592
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dotted_as_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def dotted_name(self):
            return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)


        def AS(self):
            return self.getToken(PythonParser.AS, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_dotted_as_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDotted_as_name" ):
                listener.enterDotted_as_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDotted_as_name" ):
                listener.exitDotted_as_name(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDotted_as_name" ):
                return visitor.visitDotted_as_name(self)
            else:
                return visitor.visitChildren(self)




    def dotted_as_name(self):

        localctx = PythonParser.Dotted_as_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_dotted_as_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 593
            self.dotted_name(0)
            self.state = 596
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.AS:
                self.state = 594
                self.match(PythonParser.AS)
                self.state = 595
                self.name()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TestContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def logical_test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Logical_testContext)
            else:
                return self.getTypedRuleContext(PythonParser.Logical_testContext,i)


        def IF(self):
            return self.getToken(PythonParser.IF, 0)

        def ELSE(self):
            return self.getToken(PythonParser.ELSE, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def LAMBDA(self):
            return self.getToken(PythonParser.LAMBDA, 0)

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def varargslist(self):
            return self.getTypedRuleContext(PythonParser.VarargslistContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_test

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTest" ):
                listener.enterTest(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTest" ):
                listener.exitTest(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTest" ):
                return visitor.visitTest(self)
            else:
                return visitor.visitChildren(self)




    def test(self):

        localctx = PythonParser.TestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_test)
        self._la = 0 # Token type
        try:
            self.state = 612
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.NONE, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 598
                self.logical_test(0)
                self.state = 604
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
                if la_ == 1:
                    self.state = 599
                    self.match(PythonParser.IF)
                    self.state = 600
                    self.logical_test(0)
                    self.state = 601
                    self.match(PythonParser.ELSE)
                    self.state = 602
                    self.test()


                pass
            elif token in [PythonParser.LAMBDA]:
                self.enterOuterAlt(localctx, 2)
                self.state = 606
                self.match(PythonParser.LAMBDA)
                self.state = 608
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (PythonParser.TRUE - 39)) | (1 << (PythonParser.FALSE - 39)) | (1 << (PythonParser.STAR - 39)) | (1 << (PythonParser.POWER - 39)) | (1 << (PythonParser.NAME - 39)))) != 0):
                    self.state = 607
                    self.varargslist()


                self.state = 610
                self.match(PythonParser.COLON)
                self.state = 611
                self.test()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VarargslistContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def varargs(self):
            return self.getTypedRuleContext(PythonParser.VarargsContext,0)


        def varkwargs(self):
            return self.getTypedRuleContext(PythonParser.VarkwargsContext,0)


        def vardef_parameters(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Vardef_parametersContext)
            else:
                return self.getTypedRuleContext(PythonParser.Vardef_parametersContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_varargslist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVarargslist" ):
                listener.enterVarargslist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVarargslist" ):
                listener.exitVarargslist(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVarargslist" ):
                return visitor.visitVarargslist(self)
            else:
                return visitor.visitChildren(self)




    def varargslist(self):

        localctx = PythonParser.VarargslistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_varargslist)
        self._la = 0 # Token type
        try:
            self.state = 638
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 617
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
                if la_ == 1:
                    self.state = 614
                    self.vardef_parameters()
                    self.state = 615
                    self.match(PythonParser.COMMA)


                self.state = 629
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.STAR]:
                    self.state = 619
                    self.varargs()
                    self.state = 622
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
                    if la_ == 1:
                        self.state = 620
                        self.match(PythonParser.COMMA)
                        self.state = 621
                        self.vardef_parameters()


                    self.state = 626
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,88,self._ctx)
                    if la_ == 1:
                        self.state = 624
                        self.match(PythonParser.COMMA)
                        self.state = 625
                        self.varkwargs()


                    pass
                elif token in [PythonParser.POWER]:
                    self.state = 628
                    self.varkwargs()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 632
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 631
                    self.match(PythonParser.COMMA)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 634
                self.vardef_parameters()
                self.state = 636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 635
                    self.match(PythonParser.COMMA)


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vardef_parametersContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def vardef_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Vardef_parameterContext)
            else:
                return self.getTypedRuleContext(PythonParser.Vardef_parameterContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_vardef_parameters

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVardef_parameters" ):
                listener.enterVardef_parameters(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVardef_parameters" ):
                listener.exitVardef_parameters(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVardef_parameters" ):
                return visitor.visitVardef_parameters(self)
            else:
                return visitor.visitChildren(self)




    def vardef_parameters(self):

        localctx = PythonParser.Vardef_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_vardef_parameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 640
            self.vardef_parameter()
            self.state = 645
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,93,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 641
                    self.match(PythonParser.COMMA)
                    self.state = 642
                    self.vardef_parameter() 
                self.state = 647
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,93,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vardef_parameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def ASSIGN(self):
            return self.getToken(PythonParser.ASSIGN, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_vardef_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVardef_parameter" ):
                listener.enterVardef_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVardef_parameter" ):
                listener.exitVardef_parameter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVardef_parameter" ):
                return visitor.visitVardef_parameter(self)
            else:
                return visitor.visitChildren(self)




    def vardef_parameter(self):

        localctx = PythonParser.Vardef_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_vardef_parameter)
        self._la = 0 # Token type
        try:
            self.state = 654
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 648
                self.name()
                self.state = 651
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.ASSIGN:
                    self.state = 649
                    self.match(PythonParser.ASSIGN)
                    self.state = 650
                    self.test()


                pass
            elif token in [PythonParser.STAR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 653
                self.match(PythonParser.STAR)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VarargsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_varargs

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVarargs" ):
                listener.enterVarargs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVarargs" ):
                listener.exitVarargs(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVarargs" ):
                return visitor.visitVarargs(self)
            else:
                return visitor.visitChildren(self)




    def varargs(self):

        localctx = PythonParser.VarargsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_varargs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 656
            self.match(PythonParser.STAR)
            self.state = 657
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VarkwargsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def POWER(self):
            return self.getToken(PythonParser.POWER, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_varkwargs

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVarkwargs" ):
                listener.enterVarkwargs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVarkwargs" ):
                listener.exitVarkwargs(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitVarkwargs" ):
                return visitor.visitVarkwargs(self)
            else:
                return visitor.visitChildren(self)




    def varkwargs(self):

        localctx = PythonParser.VarkwargsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_varkwargs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 659
            self.match(PythonParser.POWER)
            self.state = 660
            self.name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Logical_testContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.op = None # Token

        def comparison(self):
            return self.getTypedRuleContext(PythonParser.ComparisonContext,0)


        def NOT(self):
            return self.getToken(PythonParser.NOT, 0)

        def logical_test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Logical_testContext)
            else:
                return self.getTypedRuleContext(PythonParser.Logical_testContext,i)


        def AND(self):
            return self.getToken(PythonParser.AND, 0)

        def OR(self):
            return self.getToken(PythonParser.OR, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_logical_test

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogical_test" ):
                listener.enterLogical_test(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogical_test" ):
                listener.exitLogical_test(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLogical_test" ):
                return visitor.visitLogical_test(self)
            else:
                return visitor.visitChildren(self)



    def logical_test(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Logical_testContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 74
        self.enterRecursionRule(localctx, 74, self.RULE_logical_test, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 666
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.NONE, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                self.state = 663
                self.comparison(0)
                pass
            elif token in [PythonParser.NOT]:
                self.state = 664
                self.match(PythonParser.NOT)
                self.state = 665
                self.logical_test(3)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 676
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,98,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 674
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
                    if la_ == 1:
                        localctx = PythonParser.Logical_testContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_logical_test)
                        self.state = 668
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 669
                        localctx.op = self.match(PythonParser.AND)
                        self.state = 670
                        self.logical_test(3)
                        pass

                    elif la_ == 2:
                        localctx = PythonParser.Logical_testContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_logical_test)
                        self.state = 671
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 672
                        localctx.op = self.match(PythonParser.OR)
                        self.state = 673
                        self.logical_test(2)
                        pass

             
                self.state = 678
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,98,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ComparisonContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.optional = None # Token

        def expr(self):
            return self.getTypedRuleContext(PythonParser.ExprContext,0)


        def comparison(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.ComparisonContext)
            else:
                return self.getTypedRuleContext(PythonParser.ComparisonContext,i)


        def LESS_THAN(self):
            return self.getToken(PythonParser.LESS_THAN, 0)

        def GREATER_THAN(self):
            return self.getToken(PythonParser.GREATER_THAN, 0)

        def EQUALS(self):
            return self.getToken(PythonParser.EQUALS, 0)

        def GT_EQ(self):
            return self.getToken(PythonParser.GT_EQ, 0)

        def LT_EQ(self):
            return self.getToken(PythonParser.LT_EQ, 0)

        def NOT_EQ_1(self):
            return self.getToken(PythonParser.NOT_EQ_1, 0)

        def NOT_EQ_2(self):
            return self.getToken(PythonParser.NOT_EQ_2, 0)

        def IN(self):
            return self.getToken(PythonParser.IN, 0)

        def IS(self):
            return self.getToken(PythonParser.IS, 0)

        def NOT(self):
            return self.getToken(PythonParser.NOT, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_comparison

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComparison" ):
                listener.enterComparison(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComparison" ):
                listener.exitComparison(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComparison" ):
                return visitor.visitComparison(self)
            else:
                return visitor.visitChildren(self)



    def comparison(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.ComparisonContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 76
        self.enterRecursionRule(localctx, 76, self.RULE_comparison, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 680
            self.expr(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 703
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,102,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.ComparisonContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_comparison)
                    self.state = 682
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 698
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [PythonParser.LESS_THAN]:
                        self.state = 683
                        self.match(PythonParser.LESS_THAN)
                        pass
                    elif token in [PythonParser.GREATER_THAN]:
                        self.state = 684
                        self.match(PythonParser.GREATER_THAN)
                        pass
                    elif token in [PythonParser.EQUALS]:
                        self.state = 685
                        self.match(PythonParser.EQUALS)
                        pass
                    elif token in [PythonParser.GT_EQ]:
                        self.state = 686
                        self.match(PythonParser.GT_EQ)
                        pass
                    elif token in [PythonParser.LT_EQ]:
                        self.state = 687
                        self.match(PythonParser.LT_EQ)
                        pass
                    elif token in [PythonParser.NOT_EQ_1]:
                        self.state = 688
                        self.match(PythonParser.NOT_EQ_1)
                        pass
                    elif token in [PythonParser.NOT_EQ_2]:
                        self.state = 689
                        self.match(PythonParser.NOT_EQ_2)
                        pass
                    elif token in [PythonParser.IN, PythonParser.NOT]:
                        self.state = 691
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==PythonParser.NOT:
                            self.state = 690
                            localctx.optional = self.match(PythonParser.NOT)


                        self.state = 693
                        self.match(PythonParser.IN)
                        pass
                    elif token in [PythonParser.IS]:
                        self.state = 694
                        self.match(PythonParser.IS)
                        self.state = 696
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==PythonParser.NOT:
                            self.state = 695
                            localctx.optional = self.match(PythonParser.NOT)


                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 700
                    self.comparison(3) 
                self.state = 705
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,102,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class ExprContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.op = None # Token

        def atom(self):
            return self.getTypedRuleContext(PythonParser.AtomContext,0)


        def AWAIT(self):
            return self.getToken(PythonParser.AWAIT, 0)

        def trailer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TrailerContext)
            else:
                return self.getTypedRuleContext(PythonParser.TrailerContext,i)


        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.ExprContext)
            else:
                return self.getTypedRuleContext(PythonParser.ExprContext,i)


        def ADD(self):
            return self.getToken(PythonParser.ADD, 0)

        def MINUS(self):
            return self.getToken(PythonParser.MINUS, 0)

        def NOT_OP(self):
            return self.getToken(PythonParser.NOT_OP, 0)

        def POWER(self):
            return self.getToken(PythonParser.POWER, 0)

        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def DIV(self):
            return self.getToken(PythonParser.DIV, 0)

        def MOD(self):
            return self.getToken(PythonParser.MOD, 0)

        def IDIV(self):
            return self.getToken(PythonParser.IDIV, 0)

        def AT(self):
            return self.getToken(PythonParser.AT, 0)

        def LEFT_SHIFT(self):
            return self.getToken(PythonParser.LEFT_SHIFT, 0)

        def RIGHT_SHIFT(self):
            return self.getToken(PythonParser.RIGHT_SHIFT, 0)

        def AND_OP(self):
            return self.getToken(PythonParser.AND_OP, 0)

        def XOR(self):
            return self.getToken(PythonParser.XOR, 0)

        def OR_OP(self):
            return self.getToken(PythonParser.OR_OP, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_expr

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpr" ):
                listener.enterExpr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpr" ):
                listener.exitExpr(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpr" ):
                return visitor.visitExpr(self)
            else:
                return visitor.visitChildren(self)



    def expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 78
        self.enterRecursionRule(localctx, 78, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 719
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.state = 708
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.AWAIT:
                    self.state = 707
                    self.match(PythonParser.AWAIT)


                self.state = 710
                self.atom()
                self.state = 714
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,104,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 711
                        self.trailer() 
                    self.state = 716
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,104,self._ctx)

                pass

            elif la_ == 2:
                self.state = 717
                localctx.op = self._input.LT(1)
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0)):
                    localctx.op = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 718
                self.expr(7)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 744
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,107,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 742
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
                    if la_ == 1:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 721
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 722
                        localctx.op = self.match(PythonParser.POWER)
                        self.state = 723
                        self.expr(8)
                        pass

                    elif la_ == 2:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 724
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 725
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(((((_la - 44)) & ~0x3f) == 0 and ((1 << (_la - 44)) & ((1 << (PythonParser.STAR - 44)) | (1 << (PythonParser.DIV - 44)) | (1 << (PythonParser.MOD - 44)) | (1 << (PythonParser.IDIV - 44)) | (1 << (PythonParser.AT - 44)))) != 0)):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 726
                        self.expr(7)
                        pass

                    elif la_ == 3:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 727
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 728
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==PythonParser.ADD or _la==PythonParser.MINUS):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 729
                        self.expr(6)
                        pass

                    elif la_ == 4:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 730
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 731
                        localctx.op = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not(_la==PythonParser.LEFT_SHIFT or _la==PythonParser.RIGHT_SHIFT):
                            localctx.op = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 732
                        self.expr(5)
                        pass

                    elif la_ == 5:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 733
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 734
                        localctx.op = self.match(PythonParser.AND_OP)
                        self.state = 735
                        self.expr(4)
                        pass

                    elif la_ == 6:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 736
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 737
                        localctx.op = self.match(PythonParser.XOR)
                        self.state = 738
                        self.expr(3)
                        pass

                    elif la_ == 7:
                        localctx = PythonParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 739
                        if not self.precpred(self._ctx, 1):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                        self.state = 740
                        localctx.op = self.match(PythonParser.OR_OP)
                        self.state = 741
                        self.expr(2)
                        pass

             
                self.state = 746
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,107,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class AtomContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(PythonParser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(PythonParser.CLOSE_PAREN, 0)

        def yield_expr(self):
            return self.getTypedRuleContext(PythonParser.Yield_exprContext,0)


        def testlist_comp(self):
            return self.getTypedRuleContext(PythonParser.Testlist_compContext,0)


        def OPEN_BRACKET(self):
            return self.getToken(PythonParser.OPEN_BRACKET, 0)

        def CLOSE_BRACKET(self):
            return self.getToken(PythonParser.CLOSE_BRACKET, 0)

        def OPEN_BRACE(self):
            return self.getToken(PythonParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(PythonParser.CLOSE_BRACE, 0)

        def dictorsetmaker(self):
            return self.getTypedRuleContext(PythonParser.DictorsetmakerContext,0)


        def REVERSE_QUOTE(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.REVERSE_QUOTE)
            else:
                return self.getToken(PythonParser.REVERSE_QUOTE, i)

        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)


        def COMMA(self):
            return self.getToken(PythonParser.COMMA, 0)

        def ELLIPSIS(self):
            return self.getToken(PythonParser.ELLIPSIS, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def PRINT(self):
            return self.getToken(PythonParser.PRINT, 0)

        def EXEC(self):
            return self.getToken(PythonParser.EXEC, 0)

        def number(self):
            return self.getTypedRuleContext(PythonParser.NumberContext,0)


        def MINUS(self):
            return self.getToken(PythonParser.MINUS, 0)

        def NONE(self):
            return self.getToken(PythonParser.NONE, 0)

        def STRING(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.STRING)
            else:
                return self.getToken(PythonParser.STRING, i)

        def getRuleIndex(self):
            return PythonParser.RULE_atom

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAtom" ):
                listener.enterAtom(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAtom" ):
                listener.exitAtom(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAtom" ):
                return visitor.visitAtom(self)
            else:
                return visitor.visitChildren(self)




    def atom(self):

        localctx = PythonParser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_atom)
        self._la = 0 # Token type
        try:
            self.state = 784
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.OPEN_PAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 747
                self.match(PythonParser.OPEN_PAREN)
                self.state = 750
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.YIELD]:
                    self.state = 748
                    self.yield_expr()
                    pass
                elif token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.STAR, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                    self.state = 749
                    self.testlist_comp()
                    pass
                elif token in [PythonParser.CLOSE_PAREN]:
                    pass
                else:
                    pass
                self.state = 752
                self.match(PythonParser.CLOSE_PAREN)
                pass
            elif token in [PythonParser.OPEN_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 753
                self.match(PythonParser.OPEN_BRACKET)
                self.state = 755
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 754
                    self.testlist_comp()


                self.state = 757
                self.match(PythonParser.CLOSE_BRACKET)
                pass
            elif token in [PythonParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 758
                self.match(PythonParser.OPEN_BRACE)
                self.state = 760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 759
                    self.dictorsetmaker()


                self.state = 762
                self.match(PythonParser.CLOSE_BRACE)
                pass
            elif token in [PythonParser.REVERSE_QUOTE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 763
                self.match(PythonParser.REVERSE_QUOTE)
                self.state = 764
                self.testlist()
                self.state = 766
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 765
                    self.match(PythonParser.COMMA)


                self.state = 768
                self.match(PythonParser.REVERSE_QUOTE)
                pass
            elif token in [PythonParser.ELLIPSIS]:
                self.enterOuterAlt(localctx, 5)
                self.state = 770
                self.match(PythonParser.ELLIPSIS)
                pass
            elif token in [PythonParser.TRUE, PythonParser.FALSE, PythonParser.NAME]:
                self.enterOuterAlt(localctx, 6)
                self.state = 771
                self.name()
                pass
            elif token in [PythonParser.PRINT]:
                self.enterOuterAlt(localctx, 7)
                self.state = 772
                self.match(PythonParser.PRINT)
                pass
            elif token in [PythonParser.EXEC]:
                self.enterOuterAlt(localctx, 8)
                self.state = 773
                self.match(PythonParser.EXEC)
                pass
            elif token in [PythonParser.MINUS, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER]:
                self.enterOuterAlt(localctx, 9)
                self.state = 775
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.MINUS:
                    self.state = 774
                    self.match(PythonParser.MINUS)


                self.state = 777
                self.number()
                pass
            elif token in [PythonParser.NONE]:
                self.enterOuterAlt(localctx, 10)
                self.state = 778
                self.match(PythonParser.NONE)
                pass
            elif token in [PythonParser.STRING]:
                self.enterOuterAlt(localctx, 11)
                self.state = 780 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 779
                        self.match(PythonParser.STRING)

                    else:
                        raise NoViableAltException(self)
                    self.state = 782 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,113,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictorsetmakerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)


        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COLON)
            else:
                return self.getToken(PythonParser.COLON, i)

        def POWER(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.POWER)
            else:
                return self.getToken(PythonParser.POWER, i)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.ExprContext)
            else:
                return self.getTypedRuleContext(PythonParser.ExprContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def comp_for(self):
            return self.getTypedRuleContext(PythonParser.Comp_forContext,0)


        def testlist_comp(self):
            return self.getTypedRuleContext(PythonParser.Testlist_compContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_dictorsetmaker

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDictorsetmaker" ):
                listener.enterDictorsetmaker(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDictorsetmaker" ):
                listener.exitDictorsetmaker(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDictorsetmaker" ):
                return visitor.visitDictorsetmaker(self)
            else:
                return visitor.visitChildren(self)




    def dictorsetmaker(self):

        localctx = PythonParser.DictorsetmakerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_dictorsetmaker)
        self._la = 0 # Token type
        try:
            self.state = 817
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 792
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                    self.state = 786
                    self.test()
                    self.state = 787
                    self.match(PythonParser.COLON)
                    self.state = 788
                    self.test()
                    pass
                elif token in [PythonParser.POWER]:
                    self.state = 790
                    self.match(PythonParser.POWER)
                    self.state = 791
                    self.expr(0)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 805
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,117,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 794
                        self.match(PythonParser.COMMA)
                        self.state = 801
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                            self.state = 795
                            self.test()
                            self.state = 796
                            self.match(PythonParser.COLON)
                            self.state = 797
                            self.test()
                            pass
                        elif token in [PythonParser.POWER]:
                            self.state = 799
                            self.match(PythonParser.POWER)
                            self.state = 800
                            self.expr(0)
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 807
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,117,self._ctx)

                self.state = 809
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 808
                    self.match(PythonParser.COMMA)


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 811
                self.test()
                self.state = 812
                self.match(PythonParser.COLON)
                self.state = 813
                self.test()
                self.state = 814
                self.comp_for()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 816
                self.testlist_comp()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Testlist_compContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)


        def star_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Star_exprContext)
            else:
                return self.getTypedRuleContext(PythonParser.Star_exprContext,i)


        def comp_for(self):
            return self.getTypedRuleContext(PythonParser.Comp_forContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_testlist_comp

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTestlist_comp" ):
                listener.enterTestlist_comp(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTestlist_comp" ):
                listener.exitTestlist_comp(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTestlist_comp" ):
                return visitor.visitTestlist_comp(self)
            else:
                return visitor.visitChildren(self)




    def testlist_comp(self):

        localctx = PythonParser.Testlist_compContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_testlist_comp)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 821
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                self.state = 819
                self.test()
                pass
            elif token in [PythonParser.STAR]:
                self.state = 820
                self.star_expr()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 837
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.FOR]:
                self.state = 823
                self.comp_for()
                pass
            elif token in [PythonParser.COMMA, PythonParser.CLOSE_PAREN, PythonParser.CLOSE_BRACE, PythonParser.CLOSE_BRACKET]:
                self.state = 831
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,122,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 824
                        self.match(PythonParser.COMMA)
                        self.state = 827
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                            self.state = 825
                            self.test()
                            pass
                        elif token in [PythonParser.STAR]:
                            self.state = 826
                            self.star_expr()
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 833
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,122,self._ctx)

                self.state = 835
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COMMA:
                    self.state = 834
                    self.match(PythonParser.COMMA)


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TestlistContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_testlist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTestlist" ):
                listener.enterTestlist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTestlist" ):
                listener.exitTestlist(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTestlist" ):
                return visitor.visitTestlist(self)
            else:
                return visitor.visitChildren(self)




    def testlist(self):

        localctx = PythonParser.TestlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_testlist)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 839
            self.test()
            self.state = 844
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,125,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 840
                    self.match(PythonParser.COMMA)
                    self.state = 841
                    self.test() 
                self.state = 846
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,125,self._ctx)

            self.state = 848
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
            if la_ == 1:
                self.state = 847
                self.match(PythonParser.COMMA)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Dotted_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def dotted_name(self):
            return self.getTypedRuleContext(PythonParser.Dotted_nameContext,0)


        def DOT(self):
            return self.getToken(PythonParser.DOT, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_dotted_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDotted_name" ):
                listener.enterDotted_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDotted_name" ):
                listener.exitDotted_name(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDotted_name" ):
                return visitor.visitDotted_name(self)
            else:
                return visitor.visitChildren(self)



    def dotted_name(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Dotted_nameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 88
        self.enterRecursionRule(localctx, 88, self.RULE_dotted_name, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self.name()
            self._ctx.stop = self._input.LT(-1)
            self.state = 858
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,127,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.Dotted_nameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_dotted_name)
                    self.state = 853
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 854
                    self.match(PythonParser.DOT)
                    self.state = 855
                    self.name() 
                self.state = 860
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,127,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class NameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAME(self):
            return self.getToken(PythonParser.NAME, 0)

        def TRUE(self):
            return self.getToken(PythonParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(PythonParser.FALSE, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterName" ):
                listener.enterName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitName" ):
                listener.exitName(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitName" ):
                return visitor.visitName(self)
            else:
                return visitor.visitChildren(self)




    def name(self):

        localctx = PythonParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 861
            _la = self._input.LA(1)
            if not(((((_la - 39)) & ~0x3f) == 0 and ((1 << (_la - 39)) & ((1 << (PythonParser.TRUE - 39)) | (1 << (PythonParser.FALSE - 39)) | (1 << (PythonParser.NAME - 39)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NumberContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def integer(self):
            return self.getTypedRuleContext(PythonParser.IntegerContext,0)


        def IMAG_NUMBER(self):
            return self.getToken(PythonParser.IMAG_NUMBER, 0)

        def FLOAT_NUMBER(self):
            return self.getToken(PythonParser.FLOAT_NUMBER, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber" ):
                listener.enterNumber(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber" ):
                listener.exitNumber(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumber" ):
                return visitor.visitNumber(self)
            else:
                return visitor.visitChildren(self)




    def number(self):

        localctx = PythonParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_number)
        try:
            self.state = 866
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 863
                self.integer()
                pass
            elif token in [PythonParser.IMAG_NUMBER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 864
                self.match(PythonParser.IMAG_NUMBER)
                pass
            elif token in [PythonParser.FLOAT_NUMBER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 865
                self.match(PythonParser.FLOAT_NUMBER)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IntegerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DECIMAL_INTEGER(self):
            return self.getToken(PythonParser.DECIMAL_INTEGER, 0)

        def OCT_INTEGER(self):
            return self.getToken(PythonParser.OCT_INTEGER, 0)

        def HEX_INTEGER(self):
            return self.getToken(PythonParser.HEX_INTEGER, 0)

        def BIN_INTEGER(self):
            return self.getToken(PythonParser.BIN_INTEGER, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_integer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInteger" ):
                listener.enterInteger(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInteger" ):
                listener.exitInteger(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInteger" ):
                return visitor.visitInteger(self)
            else:
                return visitor.visitChildren(self)




    def integer(self):

        localctx = PythonParser.IntegerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_integer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 868
            _la = self._input.LA(1)
            if not(((((_la - 84)) & ~0x3f) == 0 and ((1 << (_la - 84)) & ((1 << (PythonParser.DECIMAL_INTEGER - 84)) | (1 << (PythonParser.OCT_INTEGER - 84)) | (1 << (PythonParser.HEX_INTEGER - 84)) | (1 << (PythonParser.BIN_INTEGER - 84)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Yield_exprContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def YIELD(self):
            return self.getToken(PythonParser.YIELD, 0)

        def yield_arg(self):
            return self.getTypedRuleContext(PythonParser.Yield_argContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_yield_expr

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterYield_expr" ):
                listener.enterYield_expr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitYield_expr" ):
                listener.exitYield_expr(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitYield_expr" ):
                return visitor.visitYield_expr(self)
            else:
                return visitor.visitChildren(self)




    def yield_expr(self):

        localctx = PythonParser.Yield_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_yield_expr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 870
            self.match(PythonParser.YIELD)
            self.state = 872
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.FROM) | (1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                self.state = 871
                self.yield_arg()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Yield_argContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FROM(self):
            return self.getToken(PythonParser.FROM, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def testlist(self):
            return self.getTypedRuleContext(PythonParser.TestlistContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_yield_arg

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterYield_arg" ):
                listener.enterYield_arg(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitYield_arg" ):
                listener.exitYield_arg(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitYield_arg" ):
                return visitor.visitYield_arg(self)
            else:
                return visitor.visitChildren(self)




    def yield_arg(self):

        localctx = PythonParser.Yield_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_yield_arg)
        try:
            self.state = 877
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.FROM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 874
                self.match(PythonParser.FROM)
                self.state = 875
                self.test()
                pass
            elif token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                self.enterOuterAlt(localctx, 2)
                self.state = 876
                self.testlist()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TrailerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DOT(self):
            return self.getToken(PythonParser.DOT, 0)

        def name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


        def arguments(self):
            return self.getTypedRuleContext(PythonParser.ArgumentsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_trailer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrailer" ):
                listener.enterTrailer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrailer" ):
                listener.exitTrailer(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrailer" ):
                return visitor.visitTrailer(self)
            else:
                return visitor.visitChildren(self)




    def trailer(self):

        localctx = PythonParser.TrailerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_trailer)
        try:
            self.state = 885
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.DOT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 879
                self.match(PythonParser.DOT)
                self.state = 880
                self.name()
                self.state = 882
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
                if la_ == 1:
                    self.state = 881
                    self.arguments()


                pass
            elif token in [PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 884
                self.arguments()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAREN(self):
            return self.getToken(PythonParser.OPEN_PAREN, 0)

        def CLOSE_PAREN(self):
            return self.getToken(PythonParser.CLOSE_PAREN, 0)

        def arglist(self):
            return self.getTypedRuleContext(PythonParser.ArglistContext,0)


        def OPEN_BRACKET(self):
            return self.getToken(PythonParser.OPEN_BRACKET, 0)

        def subscriptlist(self):
            return self.getTypedRuleContext(PythonParser.SubscriptlistContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(PythonParser.CLOSE_BRACKET, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_arguments

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArguments" ):
                listener.enterArguments(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArguments" ):
                listener.exitArguments(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArguments" ):
                return visitor.visitArguments(self)
            else:
                return visitor.visitChildren(self)




    def arguments(self):

        localctx = PythonParser.ArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_arguments)
        self._la = 0 # Token type
        try:
            self.state = 896
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.OPEN_PAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 887
                self.match(PythonParser.OPEN_PAREN)
                self.state = 889
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.STAR) | (1 << PythonParser.POWER) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 888
                    self.arglist()


                self.state = 891
                self.match(PythonParser.CLOSE_PAREN)
                pass
            elif token in [PythonParser.OPEN_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 892
                self.match(PythonParser.OPEN_BRACKET)
                self.state = 893
                self.subscriptlist()
                self.state = 894
                self.match(PythonParser.CLOSE_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArglistContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.ArgumentContext)
            else:
                return self.getTypedRuleContext(PythonParser.ArgumentContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_arglist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArglist" ):
                listener.enterArglist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArglist" ):
                listener.exitArglist(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArglist" ):
                return visitor.visitArglist(self)
            else:
                return visitor.visitChildren(self)




    def arglist(self):

        localctx = PythonParser.ArglistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_arglist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 898
            self.argument()
            self.state = 903
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,135,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 899
                    self.match(PythonParser.COMMA)
                    self.state = 900
                    self.argument() 
                self.state = 905
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,135,self._ctx)

            self.state = 907
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.COMMA:
                self.state = 906
                self.match(PythonParser.COMMA)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)


        def comp_for(self):
            return self.getTypedRuleContext(PythonParser.Comp_forContext,0)


        def ASSIGN(self):
            return self.getToken(PythonParser.ASSIGN, 0)

        def POWER(self):
            return self.getToken(PythonParser.POWER, 0)

        def STAR(self):
            return self.getToken(PythonParser.STAR, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_argument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArgument" ):
                listener.enterArgument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArgument" ):
                listener.exitArgument(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitArgument" ):
                return visitor.visitArgument(self)
            else:
                return visitor.visitChildren(self)




    def argument(self):

        localctx = PythonParser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_argument)
        self._la = 0 # Token type
        try:
            self.state = 917
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.NONE, PythonParser.LAMBDA, PythonParser.NOT, PythonParser.AWAIT, PythonParser.PRINT, PythonParser.EXEC, PythonParser.TRUE, PythonParser.FALSE, PythonParser.ELLIPSIS, PythonParser.REVERSE_QUOTE, PythonParser.ADD, PythonParser.MINUS, PythonParser.NOT_OP, PythonParser.STRING, PythonParser.DECIMAL_INTEGER, PythonParser.OCT_INTEGER, PythonParser.HEX_INTEGER, PythonParser.BIN_INTEGER, PythonParser.IMAG_NUMBER, PythonParser.FLOAT_NUMBER, PythonParser.OPEN_PAREN, PythonParser.OPEN_BRACE, PythonParser.OPEN_BRACKET, PythonParser.NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 909
                self.test()
                self.state = 913
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [PythonParser.FOR]:
                    self.state = 910
                    self.comp_for()
                    pass
                elif token in [PythonParser.ASSIGN]:
                    self.state = 911
                    self.match(PythonParser.ASSIGN)
                    self.state = 912
                    self.test()
                    pass
                elif token in [PythonParser.COMMA, PythonParser.CLOSE_PAREN]:
                    pass
                else:
                    pass
                pass
            elif token in [PythonParser.STAR, PythonParser.POWER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 915
                _la = self._input.LA(1)
                if not(_la==PythonParser.STAR or _la==PythonParser.POWER):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 916
                self.test()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubscriptlistContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def subscript(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.SubscriptContext)
            else:
                return self.getTypedRuleContext(PythonParser.SubscriptContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(PythonParser.COMMA)
            else:
                return self.getToken(PythonParser.COMMA, i)

        def getRuleIndex(self):
            return PythonParser.RULE_subscriptlist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubscriptlist" ):
                listener.enterSubscriptlist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubscriptlist" ):
                listener.exitSubscriptlist(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubscriptlist" ):
                return visitor.visitSubscriptlist(self)
            else:
                return visitor.visitChildren(self)




    def subscriptlist(self):

        localctx = PythonParser.SubscriptlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_subscriptlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 919
            self.subscript()
            self.state = 924
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 920
                    self.match(PythonParser.COMMA)
                    self.state = 921
                    self.subscript() 
                self.state = 926
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,139,self._ctx)

            self.state = 928
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.COMMA:
                self.state = 927
                self.match(PythonParser.COMMA)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SubscriptContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ELLIPSIS(self):
            return self.getToken(PythonParser.ELLIPSIS, 0)

        def test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.TestContext)
            else:
                return self.getTypedRuleContext(PythonParser.TestContext,i)


        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def sliceop(self):
            return self.getTypedRuleContext(PythonParser.SliceopContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_subscript

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSubscript" ):
                listener.enterSubscript(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSubscript" ):
                listener.exitSubscript(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSubscript" ):
                return visitor.visitSubscript(self)
            else:
                return visitor.visitChildren(self)




    def subscript(self):

        localctx = PythonParser.SubscriptContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_subscript)
        self._la = 0 # Token type
        try:
            self.state = 948
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 930
                self.match(PythonParser.ELLIPSIS)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 931
                self.test()
                self.state = 939
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COLON:
                    self.state = 932
                    self.match(PythonParser.COLON)
                    self.state = 934
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                        self.state = 933
                        self.test()


                    self.state = 937
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==PythonParser.COLON:
                        self.state = 936
                        self.sliceop()




                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 941
                self.match(PythonParser.COLON)
                self.state = 943
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                    self.state = 942
                    self.test()


                self.state = 946
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.COLON:
                    self.state = 945
                    self.sliceop()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SliceopContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(PythonParser.COLON, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_sliceop

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSliceop" ):
                listener.enterSliceop(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSliceop" ):
                listener.exitSliceop(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSliceop" ):
                return visitor.visitSliceop(self)
            else:
                return visitor.visitChildren(self)




    def sliceop(self):

        localctx = PythonParser.SliceopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_sliceop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 950
            self.match(PythonParser.COLON)
            self.state = 952
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << PythonParser.NONE) | (1 << PythonParser.LAMBDA) | (1 << PythonParser.NOT) | (1 << PythonParser.AWAIT) | (1 << PythonParser.PRINT) | (1 << PythonParser.EXEC) | (1 << PythonParser.TRUE) | (1 << PythonParser.FALSE) | (1 << PythonParser.ELLIPSIS) | (1 << PythonParser.REVERSE_QUOTE) | (1 << PythonParser.ADD) | (1 << PythonParser.MINUS) | (1 << PythonParser.NOT_OP))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (PythonParser.STRING - 83)) | (1 << (PythonParser.DECIMAL_INTEGER - 83)) | (1 << (PythonParser.OCT_INTEGER - 83)) | (1 << (PythonParser.HEX_INTEGER - 83)) | (1 << (PythonParser.BIN_INTEGER - 83)) | (1 << (PythonParser.IMAG_NUMBER - 83)) | (1 << (PythonParser.FLOAT_NUMBER - 83)) | (1 << (PythonParser.OPEN_PAREN - 83)) | (1 << (PythonParser.OPEN_BRACE - 83)) | (1 << (PythonParser.OPEN_BRACKET - 83)) | (1 << (PythonParser.NAME - 83)))) != 0):
                self.state = 951
                self.test()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Comp_forContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FOR(self):
            return self.getToken(PythonParser.FOR, 0)

        def exprlist(self):
            return self.getTypedRuleContext(PythonParser.ExprlistContext,0)


        def IN(self):
            return self.getToken(PythonParser.IN, 0)

        def logical_test(self):
            return self.getTypedRuleContext(PythonParser.Logical_testContext,0)


        def comp_iter(self):
            return self.getTypedRuleContext(PythonParser.Comp_iterContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_comp_for

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComp_for" ):
                listener.enterComp_for(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComp_for" ):
                listener.exitComp_for(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComp_for" ):
                return visitor.visitComp_for(self)
            else:
                return visitor.visitChildren(self)




    def comp_for(self):

        localctx = PythonParser.Comp_forContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_comp_for)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 954
            self.match(PythonParser.FOR)
            self.state = 955
            self.exprlist()
            self.state = 956
            self.match(PythonParser.IN)
            self.state = 957
            self.logical_test(0)
            self.state = 959
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==PythonParser.IF or _la==PythonParser.FOR:
                self.state = 958
                self.comp_iter()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Comp_iterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def comp_for(self):
            return self.getTypedRuleContext(PythonParser.Comp_forContext,0)


        def IF(self):
            return self.getToken(PythonParser.IF, 0)

        def test(self):
            return self.getTypedRuleContext(PythonParser.TestContext,0)


        def comp_iter(self):
            return self.getTypedRuleContext(PythonParser.Comp_iterContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_comp_iter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterComp_iter" ):
                listener.enterComp_iter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitComp_iter" ):
                listener.exitComp_iter(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitComp_iter" ):
                return visitor.visitComp_iter(self)
            else:
                return visitor.visitChildren(self)




    def comp_iter(self):

        localctx = PythonParser.Comp_iterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_comp_iter)
        self._la = 0 # Token type
        try:
            self.state = 967
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [PythonParser.FOR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 961
                self.comp_for()
                pass
            elif token in [PythonParser.IF]:
                self.enterOuterAlt(localctx, 2)
                self.state = 962
                self.match(PythonParser.IF)
                self.state = 963
                self.test()
                self.state = 965
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==PythonParser.IF or _la==PythonParser.FOR:
                    self.state = 964
                    self.comp_iter()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[12] = self.except_clause_sempred
        self._predicates[22] = self.small_stmt_sempred
        self._predicates[25] = self.assign_part_sempred
        self._predicates[37] = self.logical_test_sempred
        self._predicates[38] = self.comparison_sempred
        self._predicates[39] = self.expr_sempred
        self._predicates[44] = self.dotted_name_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def except_clause_sempred(self, localctx:Except_clauseContext, predIndex:int):
            if predIndex == 0:
                return self.CheckVersion(2)
         

            if predIndex == 1:
                return self.CheckVersion(3)
         

    def small_stmt_sempred(self, localctx:Small_stmtContext, predIndex:int):
            if predIndex == 2:
                return self.CheckVersion(2)
         

            if predIndex == 3:
                return self.CheckVersion(2)
         

            if predIndex == 4:
                return self.CheckVersion(3)
         

    def assign_part_sempred(self, localctx:Assign_partContext, predIndex:int):
            if predIndex == 5:
                return self.CheckVersion(3)
         

    def logical_test_sempred(self, localctx:Logical_testContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 1)
         

    def comparison_sempred(self, localctx:ComparisonContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 2)
         

    def expr_sempred(self, localctx:ExprContext, predIndex:int):
            if predIndex == 9:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 14:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 15:
                return self.precpred(self._ctx, 1)
         

    def dotted_name_sempred(self, localctx:Dotted_nameContext, predIndex:int):
            if predIndex == 16:
                return self.precpred(self._ctx, 2)
         




