# Generated from Python3Parser.g4 by ANTLR 4.13.1
# 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 "." in __name__:
    from .Python3ParserBase import Python3ParserBase
else:
    from Python3ParserBase import Python3ParserBase

def serializedATN():
    return [
        4,1,102,1435,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,
        2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,
        7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,
        2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,1,0,1,0,1,0,1,0,
        1,0,3,0,244,8,0,1,1,1,1,5,1,248,8,1,10,1,12,1,251,9,1,1,1,1,1,1,
        2,1,2,5,2,257,8,2,10,2,12,2,260,9,2,1,2,1,2,1,3,1,3,1,3,1,3,3,3,
        268,8,3,1,3,3,3,271,8,3,1,3,1,3,1,4,4,4,276,8,4,11,4,12,4,277,1,
        5,1,5,1,5,1,5,3,5,284,8,5,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,3,7,294,
        8,7,1,7,1,7,1,7,1,8,1,8,3,8,301,8,8,1,8,1,8,1,9,1,9,1,9,3,9,308,
        8,9,1,9,1,9,1,9,1,9,3,9,314,8,9,5,9,316,8,9,10,9,12,9,319,9,9,1,
        9,1,9,1,9,3,9,324,8,9,1,9,1,9,1,9,1,9,3,9,330,8,9,5,9,332,8,9,10,
        9,12,9,335,9,9,1,9,1,9,1,9,1,9,3,9,341,8,9,3,9,343,8,9,3,9,345,8,
        9,1,9,1,9,1,9,3,9,350,8,9,3,9,352,8,9,3,9,354,8,9,1,9,1,9,3,9,358,
        8,9,1,9,1,9,1,9,1,9,3,9,364,8,9,5,9,366,8,9,10,9,12,9,369,9,9,1,
        9,1,9,1,9,1,9,3,9,375,8,9,3,9,377,8,9,3,9,379,8,9,1,9,1,9,1,9,3,
        9,384,8,9,3,9,386,8,9,1,10,1,10,1,10,3,10,391,8,10,1,11,1,11,1,11,
        3,11,396,8,11,1,11,1,11,1,11,1,11,3,11,402,8,11,5,11,404,8,11,10,
        11,12,11,407,9,11,1,11,1,11,1,11,3,11,412,8,11,1,11,1,11,1,11,1,
        11,3,11,418,8,11,5,11,420,8,11,10,11,12,11,423,9,11,1,11,1,11,1,
        11,1,11,3,11,429,8,11,3,11,431,8,11,3,11,433,8,11,1,11,1,11,1,11,
        3,11,438,8,11,3,11,440,8,11,3,11,442,8,11,1,11,1,11,3,11,446,8,11,
        1,11,1,11,1,11,1,11,3,11,452,8,11,5,11,454,8,11,10,11,12,11,457,
        9,11,1,11,1,11,1,11,1,11,3,11,463,8,11,3,11,465,8,11,3,11,467,8,
        11,1,11,1,11,1,11,3,11,472,8,11,3,11,474,8,11,1,12,1,12,1,13,1,13,
        3,13,480,8,13,1,14,1,14,1,14,5,14,485,8,14,10,14,12,14,488,9,14,
        1,14,3,14,491,8,14,1,14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,
        1,15,3,15,503,8,15,1,16,1,16,1,16,1,16,1,16,3,16,510,8,16,1,16,1,
        16,1,16,3,16,515,8,16,5,16,517,8,16,10,16,12,16,520,9,16,3,16,522,
        8,16,1,17,1,17,1,17,1,17,3,17,528,8,17,1,18,1,18,3,18,532,8,18,1,
        18,1,18,1,18,3,18,537,8,18,5,18,539,8,18,10,18,12,18,542,9,18,1,
        18,3,18,545,8,18,1,19,1,19,1,20,1,20,1,20,1,21,1,21,1,22,1,22,1,
        22,1,22,1,22,3,22,559,8,22,1,23,1,23,1,24,1,24,1,25,1,25,3,25,567,
        8,25,1,26,1,26,1,27,1,27,1,27,1,27,3,27,575,8,27,3,27,577,8,27,1,
        28,1,28,3,28,581,8,28,1,29,1,29,1,29,1,30,1,30,5,30,588,8,30,10,
        30,12,30,591,9,30,1,30,1,30,4,30,595,8,30,11,30,12,30,596,3,30,599,
        8,30,1,30,1,30,1,30,1,30,1,30,1,30,1,30,3,30,608,8,30,1,31,1,31,
        1,31,3,31,613,8,31,1,32,1,32,1,32,3,32,618,8,32,1,33,1,33,1,33,5,
        33,623,8,33,10,33,12,33,626,9,33,1,33,3,33,629,8,33,1,34,1,34,1,
        34,5,34,634,8,34,10,34,12,34,637,9,34,1,35,1,35,1,35,5,35,642,8,
        35,10,35,12,35,645,9,35,1,36,1,36,1,36,1,36,5,36,651,8,36,10,36,
        12,36,654,9,36,1,37,1,37,1,37,1,37,5,37,660,8,37,10,37,12,37,663,
        9,37,1,38,1,38,1,38,1,38,3,38,669,8,38,1,39,1,39,1,39,1,39,1,39,
        1,39,1,39,1,39,1,39,1,39,3,39,681,8,39,1,40,1,40,1,40,1,40,3,40,
        687,8,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,5,41,698,8,
        41,10,41,12,41,701,9,41,1,41,1,41,1,41,3,41,706,8,41,1,42,1,42,1,
        42,1,42,1,42,1,42,1,42,3,42,715,8,42,1,43,1,43,1,43,1,43,1,43,1,
        43,1,43,1,43,1,43,3,43,726,8,43,1,44,1,44,1,44,1,44,1,44,1,44,1,
        44,4,44,735,8,44,11,44,12,44,736,1,44,1,44,1,44,3,44,742,8,44,1,
        44,1,44,1,44,3,44,747,8,44,1,44,1,44,1,44,3,44,752,8,44,1,45,1,45,
        1,45,1,45,5,45,758,8,45,10,45,12,45,761,9,45,1,45,1,45,1,45,1,46,
        1,46,1,46,3,46,769,8,46,1,47,1,47,1,47,1,47,3,47,775,8,47,3,47,777,
        8,47,1,48,1,48,1,48,1,48,4,48,783,8,48,11,48,12,48,784,1,48,1,48,
        3,48,789,8,48,1,49,1,49,1,49,1,49,1,49,1,49,4,49,797,8,49,11,49,
        12,49,798,1,49,1,49,1,50,1,50,1,50,3,50,806,8,50,1,50,3,50,809,8,
        50,1,51,1,51,4,51,813,8,51,11,51,12,51,814,1,51,3,51,818,8,51,1,
        52,1,52,1,52,3,52,823,8,52,1,53,1,53,1,53,3,53,828,8,53,1,53,1,53,
        1,53,1,54,1,54,1,54,1,55,1,55,3,55,838,8,55,1,56,1,56,3,56,842,8,
        56,1,57,1,57,1,57,1,57,1,58,1,58,1,58,5,58,851,8,58,10,58,12,58,
        854,9,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,3,59,864,8,59,1,
        60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,874,8,60,1,61,1,61,1,
        61,1,61,1,61,1,61,1,61,1,61,3,61,884,8,61,1,62,1,62,1,62,1,62,1,
        62,1,62,1,62,1,62,3,62,894,8,62,1,63,1,63,1,63,3,63,899,8,63,1,64,
        1,64,1,64,3,64,904,8,64,1,65,1,65,1,66,1,66,1,67,1,67,1,68,1,68,
        1,68,1,69,1,69,1,70,1,70,1,70,1,71,1,71,1,71,4,71,923,8,71,11,71,
        12,71,924,1,72,1,72,3,72,929,8,72,1,73,1,73,1,73,1,73,1,74,1,74,
        3,74,937,8,74,1,74,1,74,1,74,3,74,942,8,74,1,74,3,74,945,8,74,1,
        75,1,75,1,75,3,75,950,8,75,1,76,1,76,1,76,5,76,955,8,76,10,76,12,
        76,958,9,76,1,76,3,76,961,8,76,1,77,1,77,3,77,965,8,77,1,78,1,78,
        1,78,1,78,3,78,971,8,78,1,79,1,79,1,79,1,79,1,79,3,79,978,8,79,1,
        79,1,79,1,79,1,79,1,79,1,79,1,79,3,79,987,8,79,1,79,1,79,1,79,1,
        79,1,79,3,79,994,8,79,1,79,1,79,3,79,998,8,79,1,80,1,80,1,80,5,80,
        1003,8,80,10,80,12,80,1006,9,80,1,81,1,81,3,81,1010,8,81,1,81,1,
        81,1,81,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,
        83,1026,8,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1034,8,83,1,83,1,
        83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1044,8,83,1,83,1,83,3,83,1048,
        8,83,1,84,1,84,1,84,5,84,1053,8,84,10,84,12,84,1056,9,84,1,85,1,
        85,1,85,5,85,1061,8,85,10,85,12,85,1064,9,85,1,86,1,86,1,86,1,86,
        1,87,1,87,1,87,1,87,1,87,1,87,3,87,1076,8,87,1,87,3,87,1079,8,87,
        1,88,1,88,3,88,1083,8,88,1,89,1,89,3,89,1087,8,89,1,89,1,89,1,89,
        1,90,1,90,3,90,1094,8,90,1,90,1,90,1,90,1,91,1,91,1,91,5,91,1102,
        8,91,10,91,12,91,1105,9,91,1,92,1,92,1,92,5,92,1110,8,92,10,92,12,
        92,1113,9,92,1,93,1,93,1,93,3,93,1118,8,93,1,94,1,94,1,94,1,94,5,
        94,1124,8,94,10,94,12,94,1127,9,94,1,95,1,95,1,95,1,95,1,95,1,95,
        1,95,1,95,1,95,1,95,1,95,1,95,1,95,3,95,1142,8,95,1,96,1,96,1,96,
        1,97,1,97,1,97,4,97,1150,8,97,11,97,12,97,1151,1,97,3,97,1155,8,
        97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,
        97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,5,97,1178,8,97,10,97,
        12,97,1181,9,97,1,98,3,98,1184,8,98,1,98,1,98,5,98,1188,8,98,10,
        98,12,98,1191,9,98,1,99,1,99,1,99,3,99,1196,8,99,1,99,1,99,1,99,
        3,99,1201,8,99,1,99,1,99,1,99,3,99,1206,8,99,1,99,1,99,1,99,1,99,
        4,99,1212,8,99,11,99,12,99,1213,1,99,1,99,1,99,1,99,3,99,1220,8,
        99,1,100,1,100,1,101,1,101,3,101,1226,8,101,1,101,1,101,1,101,1,
        101,3,101,1232,8,101,5,101,1234,8,101,10,101,12,101,1237,9,101,1,
        101,3,101,1240,8,101,3,101,1242,8,101,1,102,1,102,3,102,1246,8,102,
        1,102,1,102,1,102,1,102,1,102,1,102,1,102,3,102,1255,8,102,1,103,
        1,103,1,103,5,103,1260,8,103,10,103,12,103,1263,9,103,1,103,3,103,
        1266,8,103,1,104,1,104,3,104,1270,8,104,1,104,1,104,3,104,1274,8,
        104,1,104,3,104,1277,8,104,3,104,1279,8,104,1,105,1,105,3,105,1283,
        8,105,1,106,1,106,3,106,1287,8,106,1,106,1,106,1,106,3,106,1292,
        8,106,5,106,1294,8,106,10,106,12,106,1297,9,106,1,106,3,106,1300,
        8,106,1,107,1,107,1,107,5,107,1305,8,107,10,107,12,107,1308,9,107,
        1,107,3,107,1311,8,107,1,108,1,108,1,108,1,108,1,108,1,108,3,108,
        1319,8,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,108,3,108,
        1329,8,108,5,108,1331,8,108,10,108,12,108,1334,9,108,1,108,3,108,
        1337,8,108,3,108,1339,8,108,1,108,1,108,3,108,1343,8,108,1,108,1,
        108,1,108,1,108,3,108,1349,8,108,5,108,1351,8,108,10,108,12,108,
        1354,9,108,1,108,3,108,1357,8,108,3,108,1359,8,108,3,108,1361,8,
        108,1,109,1,109,1,109,1,109,3,109,1367,8,109,1,109,3,109,1370,8,
        109,1,109,1,109,1,109,1,110,1,110,1,110,5,110,1378,8,110,10,110,
        12,110,1381,9,110,1,110,3,110,1384,8,110,1,111,1,111,3,111,1388,
        8,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,1,111,3,111,1398,
        8,111,1,112,1,112,3,112,1402,8,112,1,113,3,113,1405,8,113,1,113,
        1,113,1,113,1,113,1,113,3,113,1412,8,113,1,114,1,114,1,114,3,114,
        1417,8,114,1,115,1,115,1,116,1,116,3,116,1423,8,116,1,117,1,117,
        1,117,3,117,1428,8,117,1,118,4,118,1431,8,118,11,118,12,118,1432,
        1,118,0,1,194,119,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,
        34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,
        78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,
        116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,
        148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,
        180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,
        212,214,216,218,220,222,224,226,228,230,232,234,236,0,7,1,0,88,100,
        1,0,54,55,2,0,71,72,76,76,3,0,56,56,73,75,86,86,1,0,71,72,1,0,69,
        70,3,0,30,30,40,40,45,45,1586,0,243,1,0,0,0,2,249,1,0,0,0,4,254,
        1,0,0,0,6,263,1,0,0,0,8,275,1,0,0,0,10,279,1,0,0,0,12,285,1,0,0,
        0,14,288,1,0,0,0,16,298,1,0,0,0,18,385,1,0,0,0,20,387,1,0,0,0,22,
        473,1,0,0,0,24,475,1,0,0,0,26,479,1,0,0,0,28,481,1,0,0,0,30,502,
        1,0,0,0,32,504,1,0,0,0,34,523,1,0,0,0,36,531,1,0,0,0,38,546,1,0,
        0,0,40,548,1,0,0,0,42,551,1,0,0,0,44,558,1,0,0,0,46,560,1,0,0,0,
        48,562,1,0,0,0,50,564,1,0,0,0,52,568,1,0,0,0,54,570,1,0,0,0,56,580,
        1,0,0,0,58,582,1,0,0,0,60,585,1,0,0,0,62,609,1,0,0,0,64,614,1,0,
        0,0,66,619,1,0,0,0,68,630,1,0,0,0,70,638,1,0,0,0,72,646,1,0,0,0,
        74,655,1,0,0,0,76,664,1,0,0,0,78,680,1,0,0,0,80,682,1,0,0,0,82,688,
        1,0,0,0,84,707,1,0,0,0,86,716,1,0,0,0,88,727,1,0,0,0,90,753,1,0,
        0,0,92,765,1,0,0,0,94,770,1,0,0,0,96,788,1,0,0,0,98,790,1,0,0,0,
        100,808,1,0,0,0,102,810,1,0,0,0,104,822,1,0,0,0,106,824,1,0,0,0,
        108,832,1,0,0,0,110,837,1,0,0,0,112,841,1,0,0,0,114,843,1,0,0,0,
        116,847,1,0,0,0,118,863,1,0,0,0,120,873,1,0,0,0,122,883,1,0,0,0,
        124,893,1,0,0,0,126,898,1,0,0,0,128,903,1,0,0,0,130,905,1,0,0,0,
        132,907,1,0,0,0,134,909,1,0,0,0,136,911,1,0,0,0,138,914,1,0,0,0,
        140,916,1,0,0,0,142,919,1,0,0,0,144,928,1,0,0,0,146,930,1,0,0,0,
        148,944,1,0,0,0,150,946,1,0,0,0,152,951,1,0,0,0,154,964,1,0,0,0,
        156,970,1,0,0,0,158,997,1,0,0,0,160,999,1,0,0,0,162,1009,1,0,0,0,
        164,1014,1,0,0,0,166,1047,1,0,0,0,168,1049,1,0,0,0,170,1057,1,0,
        0,0,172,1065,1,0,0,0,174,1078,1,0,0,0,176,1082,1,0,0,0,178,1084,
        1,0,0,0,180,1091,1,0,0,0,182,1098,1,0,0,0,184,1106,1,0,0,0,186,1117,
        1,0,0,0,188,1119,1,0,0,0,190,1141,1,0,0,0,192,1143,1,0,0,0,194,1154,
        1,0,0,0,196,1183,1,0,0,0,198,1219,1,0,0,0,200,1221,1,0,0,0,202,1225,
        1,0,0,0,204,1254,1,0,0,0,206,1256,1,0,0,0,208,1278,1,0,0,0,210,1280,
        1,0,0,0,212,1286,1,0,0,0,214,1301,1,0,0,0,216,1360,1,0,0,0,218,1362,
        1,0,0,0,220,1374,1,0,0,0,222,1397,1,0,0,0,224,1401,1,0,0,0,226,1404,
        1,0,0,0,228,1413,1,0,0,0,230,1418,1,0,0,0,232,1420,1,0,0,0,234,1427,
        1,0,0,0,236,1430,1,0,0,0,238,244,5,44,0,0,239,244,3,28,14,0,240,
        241,3,78,39,0,241,242,5,44,0,0,242,244,1,0,0,0,243,238,1,0,0,0,243,
        239,1,0,0,0,243,240,1,0,0,0,244,1,1,0,0,0,245,248,5,44,0,0,246,248,
        3,26,13,0,247,245,1,0,0,0,247,246,1,0,0,0,248,251,1,0,0,0,249,247,
        1,0,0,0,249,250,1,0,0,0,250,252,1,0,0,0,251,249,1,0,0,0,252,253,
        5,0,0,1,253,3,1,0,0,0,254,258,3,214,107,0,255,257,5,44,0,0,256,255,
        1,0,0,0,257,260,1,0,0,0,258,256,1,0,0,0,258,259,1,0,0,0,259,261,
        1,0,0,0,260,258,1,0,0,0,261,262,5,0,0,1,262,5,1,0,0,0,263,264,5,
        86,0,0,264,270,3,70,35,0,265,267,5,57,0,0,266,268,3,220,110,0,267,
        266,1,0,0,0,267,268,1,0,0,0,268,269,1,0,0,0,269,271,5,58,0,0,270,
        265,1,0,0,0,270,271,1,0,0,0,271,272,1,0,0,0,272,273,5,44,0,0,273,
        7,1,0,0,0,274,276,3,6,3,0,275,274,1,0,0,0,276,277,1,0,0,0,277,275,
        1,0,0,0,277,278,1,0,0,0,278,9,1,0,0,0,279,283,3,8,4,0,280,284,3,
        218,109,0,281,284,3,14,7,0,282,284,3,12,6,0,283,280,1,0,0,0,283,
        281,1,0,0,0,283,282,1,0,0,0,284,11,1,0,0,0,285,286,5,9,0,0,286,287,
        3,14,7,0,287,13,1,0,0,0,288,289,5,15,0,0,289,290,3,200,100,0,290,
        293,3,16,8,0,291,292,5,87,0,0,292,294,3,174,87,0,293,291,1,0,0,0,
        293,294,1,0,0,0,294,295,1,0,0,0,295,296,5,60,0,0,296,297,3,96,48,
        0,297,15,1,0,0,0,298,300,5,57,0,0,299,301,3,18,9,0,300,299,1,0,0,
        0,300,301,1,0,0,0,301,302,1,0,0,0,302,303,5,58,0,0,303,17,1,0,0,
        0,304,307,3,20,10,0,305,306,5,63,0,0,306,308,3,174,87,0,307,305,
        1,0,0,0,307,308,1,0,0,0,308,317,1,0,0,0,309,310,5,59,0,0,310,313,
        3,20,10,0,311,312,5,63,0,0,312,314,3,174,87,0,313,311,1,0,0,0,313,
        314,1,0,0,0,314,316,1,0,0,0,315,309,1,0,0,0,316,319,1,0,0,0,317,
        315,1,0,0,0,317,318,1,0,0,0,318,353,1,0,0,0,319,317,1,0,0,0,320,
        351,5,59,0,0,321,323,5,56,0,0,322,324,3,20,10,0,323,322,1,0,0,0,
        323,324,1,0,0,0,324,333,1,0,0,0,325,326,5,59,0,0,326,329,3,20,10,
        0,327,328,5,63,0,0,328,330,3,174,87,0,329,327,1,0,0,0,329,330,1,
        0,0,0,330,332,1,0,0,0,331,325,1,0,0,0,332,335,1,0,0,0,333,331,1,
        0,0,0,333,334,1,0,0,0,334,344,1,0,0,0,335,333,1,0,0,0,336,342,5,
        59,0,0,337,338,5,62,0,0,338,340,3,20,10,0,339,341,5,59,0,0,340,339,
        1,0,0,0,340,341,1,0,0,0,341,343,1,0,0,0,342,337,1,0,0,0,342,343,
        1,0,0,0,343,345,1,0,0,0,344,336,1,0,0,0,344,345,1,0,0,0,345,352,
        1,0,0,0,346,347,5,62,0,0,347,349,3,20,10,0,348,350,5,59,0,0,349,
        348,1,0,0,0,349,350,1,0,0,0,350,352,1,0,0,0,351,321,1,0,0,0,351,
        346,1,0,0,0,351,352,1,0,0,0,352,354,1,0,0,0,353,320,1,0,0,0,353,
        354,1,0,0,0,354,386,1,0,0,0,355,357,5,56,0,0,356,358,3,20,10,0,357,
        356,1,0,0,0,357,358,1,0,0,0,358,367,1,0,0,0,359,360,5,59,0,0,360,
        363,3,20,10,0,361,362,5,63,0,0,362,364,3,174,87,0,363,361,1,0,0,
        0,363,364,1,0,0,0,364,366,1,0,0,0,365,359,1,0,0,0,366,369,1,0,0,
        0,367,365,1,0,0,0,367,368,1,0,0,0,368,378,1,0,0,0,369,367,1,0,0,
        0,370,376,5,59,0,0,371,372,5,62,0,0,372,374,3,20,10,0,373,375,5,
        59,0,0,374,373,1,0,0,0,374,375,1,0,0,0,375,377,1,0,0,0,376,371,1,
        0,0,0,376,377,1,0,0,0,377,379,1,0,0,0,378,370,1,0,0,0,378,379,1,
        0,0,0,379,386,1,0,0,0,380,381,5,62,0,0,381,383,3,20,10,0,382,384,
        5,59,0,0,383,382,1,0,0,0,383,384,1,0,0,0,384,386,1,0,0,0,385,304,
        1,0,0,0,385,355,1,0,0,0,385,380,1,0,0,0,386,19,1,0,0,0,387,390,3,
        200,100,0,388,389,5,60,0,0,389,391,3,174,87,0,390,388,1,0,0,0,390,
        391,1,0,0,0,391,21,1,0,0,0,392,395,3,24,12,0,393,394,5,63,0,0,394,
        396,3,174,87,0,395,393,1,0,0,0,395,396,1,0,0,0,396,405,1,0,0,0,397,
        398,5,59,0,0,398,401,3,24,12,0,399,400,5,63,0,0,400,402,3,174,87,
        0,401,399,1,0,0,0,401,402,1,0,0,0,402,404,1,0,0,0,403,397,1,0,0,
        0,404,407,1,0,0,0,405,403,1,0,0,0,405,406,1,0,0,0,406,441,1,0,0,
        0,407,405,1,0,0,0,408,439,5,59,0,0,409,411,5,56,0,0,410,412,3,24,
        12,0,411,410,1,0,0,0,411,412,1,0,0,0,412,421,1,0,0,0,413,414,5,59,
        0,0,414,417,3,24,12,0,415,416,5,63,0,0,416,418,3,174,87,0,417,415,
        1,0,0,0,417,418,1,0,0,0,418,420,1,0,0,0,419,413,1,0,0,0,420,423,
        1,0,0,0,421,419,1,0,0,0,421,422,1,0,0,0,422,432,1,0,0,0,423,421,
        1,0,0,0,424,430,5,59,0,0,425,426,5,62,0,0,426,428,3,24,12,0,427,
        429,5,59,0,0,428,427,1,0,0,0,428,429,1,0,0,0,429,431,1,0,0,0,430,
        425,1,0,0,0,430,431,1,0,0,0,431,433,1,0,0,0,432,424,1,0,0,0,432,
        433,1,0,0,0,433,440,1,0,0,0,434,435,5,62,0,0,435,437,3,24,12,0,436,
        438,5,59,0,0,437,436,1,0,0,0,437,438,1,0,0,0,438,440,1,0,0,0,439,
        409,1,0,0,0,439,434,1,0,0,0,439,440,1,0,0,0,440,442,1,0,0,0,441,
        408,1,0,0,0,441,442,1,0,0,0,442,474,1,0,0,0,443,445,5,56,0,0,444,
        446,3,24,12,0,445,444,1,0,0,0,445,446,1,0,0,0,446,455,1,0,0,0,447,
        448,5,59,0,0,448,451,3,24,12,0,449,450,5,63,0,0,450,452,3,174,87,
        0,451,449,1,0,0,0,451,452,1,0,0,0,452,454,1,0,0,0,453,447,1,0,0,
        0,454,457,1,0,0,0,455,453,1,0,0,0,455,456,1,0,0,0,456,466,1,0,0,
        0,457,455,1,0,0,0,458,464,5,59,0,0,459,460,5,62,0,0,460,462,3,24,
        12,0,461,463,5,59,0,0,462,461,1,0,0,0,462,463,1,0,0,0,463,465,1,
        0,0,0,464,459,1,0,0,0,464,465,1,0,0,0,465,467,1,0,0,0,466,458,1,
        0,0,0,466,467,1,0,0,0,467,474,1,0,0,0,468,469,5,62,0,0,469,471,3,
        24,12,0,470,472,5,59,0,0,471,470,1,0,0,0,471,472,1,0,0,0,472,474,
        1,0,0,0,473,392,1,0,0,0,473,443,1,0,0,0,473,468,1,0,0,0,474,23,1,
        0,0,0,475,476,3,200,100,0,476,25,1,0,0,0,477,480,3,28,14,0,478,480,
        3,78,39,0,479,477,1,0,0,0,479,478,1,0,0,0,480,27,1,0,0,0,481,486,
        3,30,15,0,482,483,5,61,0,0,483,485,3,30,15,0,484,482,1,0,0,0,485,
        488,1,0,0,0,486,484,1,0,0,0,486,487,1,0,0,0,487,490,1,0,0,0,488,
        486,1,0,0,0,489,491,5,61,0,0,490,489,1,0,0,0,490,491,1,0,0,0,491,
        492,1,0,0,0,492,493,5,44,0,0,493,29,1,0,0,0,494,503,3,32,16,0,495,
        503,3,40,20,0,496,503,3,42,21,0,497,503,3,44,22,0,498,503,3,56,28,
        0,499,503,3,72,36,0,500,503,3,74,37,0,501,503,3,76,38,0,502,494,
        1,0,0,0,502,495,1,0,0,0,502,496,1,0,0,0,502,497,1,0,0,0,502,498,
        1,0,0,0,502,499,1,0,0,0,502,500,1,0,0,0,502,501,1,0,0,0,503,31,1,
        0,0,0,504,521,3,36,18,0,505,522,3,34,17,0,506,509,3,38,19,0,507,
        510,3,232,116,0,508,510,3,214,107,0,509,507,1,0,0,0,509,508,1,0,
        0,0,510,522,1,0,0,0,511,514,5,63,0,0,512,515,3,232,116,0,513,515,
        3,36,18,0,514,512,1,0,0,0,514,513,1,0,0,0,515,517,1,0,0,0,516,511,
        1,0,0,0,517,520,1,0,0,0,518,516,1,0,0,0,518,519,1,0,0,0,519,522,
        1,0,0,0,520,518,1,0,0,0,521,505,1,0,0,0,521,506,1,0,0,0,521,518,
        1,0,0,0,522,33,1,0,0,0,523,524,5,60,0,0,524,527,3,174,87,0,525,526,
        5,63,0,0,526,528,3,174,87,0,527,525,1,0,0,0,527,528,1,0,0,0,528,
        35,1,0,0,0,529,532,3,174,87,0,530,532,3,192,96,0,531,529,1,0,0,0,
        531,530,1,0,0,0,532,540,1,0,0,0,533,536,5,59,0,0,534,537,3,174,87,
        0,535,537,3,192,96,0,536,534,1,0,0,0,536,535,1,0,0,0,537,539,1,0,
        0,0,538,533,1,0,0,0,539,542,1,0,0,0,540,538,1,0,0,0,540,541,1,0,
        0,0,541,544,1,0,0,0,542,540,1,0,0,0,543,545,5,59,0,0,544,543,1,0,
        0,0,544,545,1,0,0,0,545,37,1,0,0,0,546,547,7,0,0,0,547,39,1,0,0,
        0,548,549,5,16,0,0,549,550,3,212,106,0,550,41,1,0,0,0,551,552,5,
        35,0,0,552,43,1,0,0,0,553,559,3,46,23,0,554,559,3,48,24,0,555,559,
        3,50,25,0,556,559,3,54,27,0,557,559,3,52,26,0,558,553,1,0,0,0,558,
        554,1,0,0,0,558,555,1,0,0,0,558,556,1,0,0,0,558,557,1,0,0,0,559,
        45,1,0,0,0,560,561,5,11,0,0,561,47,1,0,0,0,562,563,5,14,0,0,563,
        49,1,0,0,0,564,566,5,37,0,0,565,567,3,214,107,0,566,565,1,0,0,0,
        566,567,1,0,0,0,567,51,1,0,0,0,568,569,3,232,116,0,569,53,1,0,0,
        0,570,576,5,36,0,0,571,574,3,174,87,0,572,573,5,23,0,0,573,575,3,
        174,87,0,574,572,1,0,0,0,574,575,1,0,0,0,575,577,1,0,0,0,576,571,
        1,0,0,0,576,577,1,0,0,0,577,55,1,0,0,0,578,581,3,58,29,0,579,581,
        3,60,30,0,580,578,1,0,0,0,580,579,1,0,0,0,581,57,1,0,0,0,582,583,
        5,26,0,0,583,584,3,68,34,0,584,59,1,0,0,0,585,598,5,23,0,0,586,588,
        7,1,0,0,587,586,1,0,0,0,588,591,1,0,0,0,589,587,1,0,0,0,589,590,
        1,0,0,0,590,592,1,0,0,0,591,589,1,0,0,0,592,599,3,70,35,0,593,595,
        7,1,0,0,594,593,1,0,0,0,595,596,1,0,0,0,596,594,1,0,0,0,596,597,
        1,0,0,0,597,599,1,0,0,0,598,589,1,0,0,0,598,594,1,0,0,0,599,600,
        1,0,0,0,600,607,5,26,0,0,601,608,5,56,0,0,602,603,5,57,0,0,603,604,
        3,66,33,0,604,605,5,58,0,0,605,608,1,0,0,0,606,608,3,66,33,0,607,
        601,1,0,0,0,607,602,1,0,0,0,607,606,1,0,0,0,608,61,1,0,0,0,609,612,
        3,200,100,0,610,611,5,7,0,0,611,613,3,200,100,0,612,610,1,0,0,0,
        612,613,1,0,0,0,613,63,1,0,0,0,614,617,3,70,35,0,615,616,5,7,0,0,
        616,618,3,200,100,0,617,615,1,0,0,0,617,618,1,0,0,0,618,65,1,0,0,
        0,619,624,3,62,31,0,620,621,5,59,0,0,621,623,3,62,31,0,622,620,1,
        0,0,0,623,626,1,0,0,0,624,622,1,0,0,0,624,625,1,0,0,0,625,628,1,
        0,0,0,626,624,1,0,0,0,627,629,5,59,0,0,628,627,1,0,0,0,628,629,1,
        0,0,0,629,67,1,0,0,0,630,635,3,64,32,0,631,632,5,59,0,0,632,634,
        3,64,32,0,633,631,1,0,0,0,634,637,1,0,0,0,635,633,1,0,0,0,635,636,
        1,0,0,0,636,69,1,0,0,0,637,635,1,0,0,0,638,643,3,200,100,0,639,640,
        5,54,0,0,640,642,3,200,100,0,641,639,1,0,0,0,642,645,1,0,0,0,643,
        641,1,0,0,0,643,644,1,0,0,0,644,71,1,0,0,0,645,643,1,0,0,0,646,647,
        5,24,0,0,647,652,3,200,100,0,648,649,5,59,0,0,649,651,3,200,100,
        0,650,648,1,0,0,0,651,654,1,0,0,0,652,650,1,0,0,0,652,653,1,0,0,
        0,653,73,1,0,0,0,654,652,1,0,0,0,655,656,5,32,0,0,656,661,3,200,
        100,0,657,658,5,59,0,0,658,660,3,200,100,0,659,657,1,0,0,0,660,663,
        1,0,0,0,661,659,1,0,0,0,661,662,1,0,0,0,662,75,1,0,0,0,663,661,1,
        0,0,0,664,665,5,8,0,0,665,668,3,174,87,0,666,667,5,59,0,0,667,669,
        3,174,87,0,668,666,1,0,0,0,668,669,1,0,0,0,669,77,1,0,0,0,670,681,
        3,82,41,0,671,681,3,84,42,0,672,681,3,86,43,0,673,681,3,88,44,0,
        674,681,3,90,45,0,675,681,3,14,7,0,676,681,3,218,109,0,677,681,3,
        10,5,0,678,681,3,80,40,0,679,681,3,98,49,0,680,670,1,0,0,0,680,671,
        1,0,0,0,680,672,1,0,0,0,680,673,1,0,0,0,680,674,1,0,0,0,680,675,
        1,0,0,0,680,676,1,0,0,0,680,677,1,0,0,0,680,678,1,0,0,0,680,679,
        1,0,0,0,681,79,1,0,0,0,682,686,5,9,0,0,683,687,3,14,7,0,684,687,
        3,90,45,0,685,687,3,86,43,0,686,683,1,0,0,0,686,684,1,0,0,0,686,
        685,1,0,0,0,687,81,1,0,0,0,688,689,5,25,0,0,689,690,3,174,87,0,690,
        691,5,60,0,0,691,699,3,96,48,0,692,693,5,17,0,0,693,694,3,174,87,
        0,694,695,5,60,0,0,695,696,3,96,48,0,696,698,1,0,0,0,697,692,1,0,
        0,0,698,701,1,0,0,0,699,697,1,0,0,0,699,700,1,0,0,0,700,705,1,0,
        0,0,701,699,1,0,0,0,702,703,5,18,0,0,703,704,5,60,0,0,704,706,3,
        96,48,0,705,702,1,0,0,0,705,706,1,0,0,0,706,83,1,0,0,0,707,708,5,
        41,0,0,708,709,3,174,87,0,709,710,5,60,0,0,710,714,3,96,48,0,711,
        712,5,18,0,0,712,713,5,60,0,0,713,715,3,96,48,0,714,711,1,0,0,0,
        714,715,1,0,0,0,715,85,1,0,0,0,716,717,5,22,0,0,717,718,3,212,106,
        0,718,719,5,27,0,0,719,720,3,214,107,0,720,721,5,60,0,0,721,725,
        3,96,48,0,722,723,5,18,0,0,723,724,5,60,0,0,724,726,3,96,48,0,725,
        722,1,0,0,0,725,726,1,0,0,0,726,87,1,0,0,0,727,728,5,39,0,0,728,
        729,5,60,0,0,729,751,3,96,48,0,730,731,3,94,47,0,731,732,5,60,0,
        0,732,733,3,96,48,0,733,735,1,0,0,0,734,730,1,0,0,0,735,736,1,0,
        0,0,736,734,1,0,0,0,736,737,1,0,0,0,737,741,1,0,0,0,738,739,5,18,
        0,0,739,740,5,60,0,0,740,742,3,96,48,0,741,738,1,0,0,0,741,742,1,
        0,0,0,742,746,1,0,0,0,743,744,5,21,0,0,744,745,5,60,0,0,745,747,
        3,96,48,0,746,743,1,0,0,0,746,747,1,0,0,0,747,752,1,0,0,0,748,749,
        5,21,0,0,749,750,5,60,0,0,750,752,3,96,48,0,751,734,1,0,0,0,751,
        748,1,0,0,0,752,89,1,0,0,0,753,754,5,42,0,0,754,759,3,92,46,0,755,
        756,5,59,0,0,756,758,3,92,46,0,757,755,1,0,0,0,758,761,1,0,0,0,759,
        757,1,0,0,0,759,760,1,0,0,0,760,762,1,0,0,0,761,759,1,0,0,0,762,
        763,5,60,0,0,763,764,3,96,48,0,764,91,1,0,0,0,765,768,3,174,87,0,
        766,767,5,7,0,0,767,769,3,194,97,0,768,766,1,0,0,0,768,769,1,0,0,
        0,769,93,1,0,0,0,770,776,5,19,0,0,771,774,3,174,87,0,772,773,5,7,
        0,0,773,775,3,200,100,0,774,772,1,0,0,0,774,775,1,0,0,0,775,777,
        1,0,0,0,776,771,1,0,0,0,776,777,1,0,0,0,777,95,1,0,0,0,778,789,3,
        28,14,0,779,780,5,44,0,0,780,782,5,1,0,0,781,783,3,26,13,0,782,781,
        1,0,0,0,783,784,1,0,0,0,784,782,1,0,0,0,784,785,1,0,0,0,785,786,
        1,0,0,0,786,787,5,2,0,0,787,789,1,0,0,0,788,778,1,0,0,0,788,779,
        1,0,0,0,789,97,1,0,0,0,790,791,5,30,0,0,791,792,3,100,50,0,792,793,
        5,60,0,0,793,794,5,44,0,0,794,796,5,1,0,0,795,797,3,106,53,0,796,
        795,1,0,0,0,797,798,1,0,0,0,798,796,1,0,0,0,798,799,1,0,0,0,799,
        800,1,0,0,0,800,801,5,2,0,0,801,99,1,0,0,0,802,803,3,104,52,0,803,
        805,5,59,0,0,804,806,3,102,51,0,805,804,1,0,0,0,805,806,1,0,0,0,
        806,809,1,0,0,0,807,809,3,174,87,0,808,802,1,0,0,0,808,807,1,0,0,
        0,809,101,1,0,0,0,810,812,5,59,0,0,811,813,3,104,52,0,812,811,1,
        0,0,0,813,814,1,0,0,0,814,812,1,0,0,0,814,815,1,0,0,0,815,817,1,
        0,0,0,816,818,5,59,0,0,817,816,1,0,0,0,817,818,1,0,0,0,818,103,1,
        0,0,0,819,820,5,56,0,0,820,823,3,194,97,0,821,823,3,174,87,0,822,
        819,1,0,0,0,822,821,1,0,0,0,823,105,1,0,0,0,824,825,5,12,0,0,825,
        827,3,110,55,0,826,828,3,108,54,0,827,826,1,0,0,0,827,828,1,0,0,
        0,828,829,1,0,0,0,829,830,5,60,0,0,830,831,3,96,48,0,831,107,1,0,
        0,0,832,833,5,25,0,0,833,834,3,174,87,0,834,109,1,0,0,0,835,838,
        3,150,75,0,836,838,3,112,56,0,837,835,1,0,0,0,837,836,1,0,0,0,838,
        111,1,0,0,0,839,842,3,114,57,0,840,842,3,116,58,0,841,839,1,0,0,
        0,841,840,1,0,0,0,842,113,1,0,0,0,843,844,3,116,58,0,844,845,5,7,
        0,0,845,846,3,136,68,0,846,115,1,0,0,0,847,852,3,118,59,0,848,849,
        5,66,0,0,849,851,3,118,59,0,850,848,1,0,0,0,851,854,1,0,0,0,852,
        850,1,0,0,0,852,853,1,0,0,0,853,117,1,0,0,0,854,852,1,0,0,0,855,
        864,3,120,60,0,856,864,3,134,67,0,857,864,3,138,69,0,858,864,3,140,
        70,0,859,864,3,146,73,0,860,864,3,148,74,0,861,864,3,158,79,0,862,
        864,3,166,83,0,863,855,1,0,0,0,863,856,1,0,0,0,863,857,1,0,0,0,863,
        858,1,0,0,0,863,859,1,0,0,0,863,860,1,0,0,0,863,861,1,0,0,0,863,
        862,1,0,0,0,864,119,1,0,0,0,865,866,3,126,63,0,866,867,4,60,0,0,
        867,874,1,0,0,0,868,874,3,124,62,0,869,874,3,236,118,0,870,874,5,
        31,0,0,871,874,5,38,0,0,872,874,5,20,0,0,873,865,1,0,0,0,873,868,
        1,0,0,0,873,869,1,0,0,0,873,870,1,0,0,0,873,871,1,0,0,0,873,872,
        1,0,0,0,874,121,1,0,0,0,875,876,3,126,63,0,876,877,4,61,1,0,877,
        884,1,0,0,0,878,884,3,124,62,0,879,884,3,236,118,0,880,884,5,31,
        0,0,881,884,5,38,0,0,882,884,5,20,0,0,883,875,1,0,0,0,883,878,1,
        0,0,0,883,879,1,0,0,0,883,880,1,0,0,0,883,881,1,0,0,0,883,882,1,
        0,0,0,884,123,1,0,0,0,885,886,3,128,64,0,886,887,5,71,0,0,887,888,
        3,132,66,0,888,894,1,0,0,0,889,890,3,128,64,0,890,891,5,72,0,0,891,
        892,3,132,66,0,892,894,1,0,0,0,893,885,1,0,0,0,893,889,1,0,0,0,894,
        125,1,0,0,0,895,899,5,4,0,0,896,897,5,72,0,0,897,899,5,4,0,0,898,
        895,1,0,0,0,898,896,1,0,0,0,899,127,1,0,0,0,900,904,3,130,65,0,901,
        902,5,72,0,0,902,904,3,130,65,0,903,900,1,0,0,0,903,901,1,0,0,0,
        904,129,1,0,0,0,905,906,5,4,0,0,906,131,1,0,0,0,907,908,5,4,0,0,
        908,133,1,0,0,0,909,910,3,136,68,0,910,135,1,0,0,0,911,912,3,200,
        100,0,912,913,4,68,2,0,913,137,1,0,0,0,914,915,5,40,0,0,915,139,
        1,0,0,0,916,917,3,142,71,0,917,918,4,70,3,0,918,141,1,0,0,0,919,
        922,3,200,100,0,920,921,5,54,0,0,921,923,3,200,100,0,922,920,1,0,
        0,0,923,924,1,0,0,0,924,922,1,0,0,0,924,925,1,0,0,0,925,143,1,0,
        0,0,926,929,3,142,71,0,927,929,3,200,100,0,928,926,1,0,0,0,928,927,
        1,0,0,0,929,145,1,0,0,0,930,931,5,57,0,0,931,932,3,112,56,0,932,
        933,5,58,0,0,933,147,1,0,0,0,934,936,5,64,0,0,935,937,3,152,76,0,
        936,935,1,0,0,0,936,937,1,0,0,0,937,938,1,0,0,0,938,945,5,65,0,0,
        939,941,5,57,0,0,940,942,3,150,75,0,941,940,1,0,0,0,941,942,1,0,
        0,0,942,943,1,0,0,0,943,945,5,58,0,0,944,934,1,0,0,0,944,939,1,0,
        0,0,945,149,1,0,0,0,946,947,3,154,77,0,947,949,5,59,0,0,948,950,
        3,152,76,0,949,948,1,0,0,0,949,950,1,0,0,0,950,151,1,0,0,0,951,956,
        3,154,77,0,952,953,5,59,0,0,953,955,3,154,77,0,954,952,1,0,0,0,955,
        958,1,0,0,0,956,954,1,0,0,0,956,957,1,0,0,0,957,960,1,0,0,0,958,
        956,1,0,0,0,959,961,5,59,0,0,960,959,1,0,0,0,960,961,1,0,0,0,961,
        153,1,0,0,0,962,965,3,156,78,0,963,965,3,112,56,0,964,962,1,0,0,
        0,964,963,1,0,0,0,965,155,1,0,0,0,966,967,5,56,0,0,967,971,3,136,
        68,0,968,969,5,56,0,0,969,971,3,138,69,0,970,966,1,0,0,0,970,968,
        1,0,0,0,971,157,1,0,0,0,972,973,5,77,0,0,973,998,5,78,0,0,974,975,
        5,77,0,0,975,977,3,164,82,0,976,978,5,59,0,0,977,976,1,0,0,0,977,
        978,1,0,0,0,978,979,1,0,0,0,979,980,5,78,0,0,980,998,1,0,0,0,981,
        982,5,77,0,0,982,983,3,160,80,0,983,984,5,59,0,0,984,986,3,164,82,
        0,985,987,5,59,0,0,986,985,1,0,0,0,986,987,1,0,0,0,987,988,1,0,0,
        0,988,989,5,78,0,0,989,998,1,0,0,0,990,991,5,77,0,0,991,993,3,160,
        80,0,992,994,5,59,0,0,993,992,1,0,0,0,993,994,1,0,0,0,994,995,1,
        0,0,0,995,996,5,78,0,0,996,998,1,0,0,0,997,972,1,0,0,0,997,974,1,
        0,0,0,997,981,1,0,0,0,997,990,1,0,0,0,998,159,1,0,0,0,999,1004,3,
        162,81,0,1000,1001,5,59,0,0,1001,1003,3,162,81,0,1002,1000,1,0,0,
        0,1003,1006,1,0,0,0,1004,1002,1,0,0,0,1004,1005,1,0,0,0,1005,161,
        1,0,0,0,1006,1004,1,0,0,0,1007,1010,3,122,61,0,1008,1010,3,142,71,
        0,1009,1007,1,0,0,0,1009,1008,1,0,0,0,1010,1011,1,0,0,0,1011,1012,
        5,60,0,0,1012,1013,3,112,56,0,1013,163,1,0,0,0,1014,1015,5,62,0,
        0,1015,1016,3,136,68,0,1016,165,1,0,0,0,1017,1018,3,144,72,0,1018,
        1019,5,57,0,0,1019,1020,5,58,0,0,1020,1048,1,0,0,0,1021,1022,3,144,
        72,0,1022,1023,5,57,0,0,1023,1025,3,168,84,0,1024,1026,5,59,0,0,
        1025,1024,1,0,0,0,1025,1026,1,0,0,0,1026,1027,1,0,0,0,1027,1028,
        5,58,0,0,1028,1048,1,0,0,0,1029,1030,3,144,72,0,1030,1031,5,57,0,
        0,1031,1033,3,170,85,0,1032,1034,5,59,0,0,1033,1032,1,0,0,0,1033,
        1034,1,0,0,0,1034,1035,1,0,0,0,1035,1036,5,58,0,0,1036,1048,1,0,
        0,0,1037,1038,3,144,72,0,1038,1039,5,57,0,0,1039,1040,3,168,84,0,
        1040,1041,5,59,0,0,1041,1043,3,170,85,0,1042,1044,5,59,0,0,1043,
        1042,1,0,0,0,1043,1044,1,0,0,0,1044,1045,1,0,0,0,1045,1046,5,58,
        0,0,1046,1048,1,0,0,0,1047,1017,1,0,0,0,1047,1021,1,0,0,0,1047,1029,
        1,0,0,0,1047,1037,1,0,0,0,1048,167,1,0,0,0,1049,1054,3,112,56,0,
        1050,1051,5,59,0,0,1051,1053,3,112,56,0,1052,1050,1,0,0,0,1053,1056,
        1,0,0,0,1054,1052,1,0,0,0,1054,1055,1,0,0,0,1055,169,1,0,0,0,1056,
        1054,1,0,0,0,1057,1062,3,172,86,0,1058,1059,5,59,0,0,1059,1061,3,
        172,86,0,1060,1058,1,0,0,0,1061,1064,1,0,0,0,1062,1060,1,0,0,0,1062,
        1063,1,0,0,0,1063,171,1,0,0,0,1064,1062,1,0,0,0,1065,1066,3,200,
        100,0,1066,1067,5,63,0,0,1067,1068,3,112,56,0,1068,173,1,0,0,0,1069,
        1075,3,182,91,0,1070,1071,5,25,0,0,1071,1072,3,182,91,0,1072,1073,
        5,18,0,0,1073,1074,3,174,87,0,1074,1076,1,0,0,0,1075,1070,1,0,0,
        0,1075,1076,1,0,0,0,1076,1079,1,0,0,0,1077,1079,3,178,89,0,1078,
        1069,1,0,0,0,1078,1077,1,0,0,0,1079,175,1,0,0,0,1080,1083,3,182,
        91,0,1081,1083,3,180,90,0,1082,1080,1,0,0,0,1082,1081,1,0,0,0,1083,
        177,1,0,0,0,1084,1086,5,29,0,0,1085,1087,3,22,11,0,1086,1085,1,0,
        0,0,1086,1087,1,0,0,0,1087,1088,1,0,0,0,1088,1089,5,60,0,0,1089,
        1090,3,174,87,0,1090,179,1,0,0,0,1091,1093,5,29,0,0,1092,1094,3,
        22,11,0,1093,1092,1,0,0,0,1093,1094,1,0,0,0,1094,1095,1,0,0,0,1095,
        1096,5,60,0,0,1096,1097,3,176,88,0,1097,181,1,0,0,0,1098,1103,3,
        184,92,0,1099,1100,5,34,0,0,1100,1102,3,184,92,0,1101,1099,1,0,0,
        0,1102,1105,1,0,0,0,1103,1101,1,0,0,0,1103,1104,1,0,0,0,1104,183,
        1,0,0,0,1105,1103,1,0,0,0,1106,1111,3,186,93,0,1107,1108,5,6,0,0,
        1108,1110,3,186,93,0,1109,1107,1,0,0,0,1110,1113,1,0,0,0,1111,1109,
        1,0,0,0,1111,1112,1,0,0,0,1112,185,1,0,0,0,1113,1111,1,0,0,0,1114,
        1115,5,33,0,0,1115,1118,3,186,93,0,1116,1118,3,188,94,0,1117,1114,
        1,0,0,0,1117,1116,1,0,0,0,1118,187,1,0,0,0,1119,1125,3,194,97,0,
        1120,1121,3,190,95,0,1121,1122,3,194,97,0,1122,1124,1,0,0,0,1123,
        1120,1,0,0,0,1124,1127,1,0,0,0,1125,1123,1,0,0,0,1125,1126,1,0,0,
        0,1126,189,1,0,0,0,1127,1125,1,0,0,0,1128,1142,5,79,0,0,1129,1142,
        5,80,0,0,1130,1142,5,81,0,0,1131,1142,5,82,0,0,1132,1142,5,83,0,
        0,1133,1142,5,84,0,0,1134,1142,5,85,0,0,1135,1142,5,27,0,0,1136,
        1137,5,33,0,0,1137,1142,5,27,0,0,1138,1142,5,28,0,0,1139,1140,5,
        28,0,0,1140,1142,5,33,0,0,1141,1128,1,0,0,0,1141,1129,1,0,0,0,1141,
        1130,1,0,0,0,1141,1131,1,0,0,0,1141,1132,1,0,0,0,1141,1133,1,0,0,
        0,1141,1134,1,0,0,0,1141,1135,1,0,0,0,1141,1136,1,0,0,0,1141,1138,
        1,0,0,0,1141,1139,1,0,0,0,1142,191,1,0,0,0,1143,1144,5,56,0,0,1144,
        1145,3,194,97,0,1145,193,1,0,0,0,1146,1147,6,97,-1,0,1147,1155,3,
        196,98,0,1148,1150,7,2,0,0,1149,1148,1,0,0,0,1150,1151,1,0,0,0,1151,
        1149,1,0,0,0,1151,1152,1,0,0,0,1152,1153,1,0,0,0,1153,1155,3,194,
        97,7,1154,1146,1,0,0,0,1154,1149,1,0,0,0,1155,1179,1,0,0,0,1156,
        1157,10,8,0,0,1157,1158,5,62,0,0,1158,1178,3,194,97,9,1159,1160,
        10,6,0,0,1160,1161,7,3,0,0,1161,1178,3,194,97,7,1162,1163,10,5,0,
        0,1163,1164,7,4,0,0,1164,1178,3,194,97,6,1165,1166,10,4,0,0,1166,
        1167,7,5,0,0,1167,1178,3,194,97,5,1168,1169,10,3,0,0,1169,1170,5,
        68,0,0,1170,1178,3,194,97,4,1171,1172,10,2,0,0,1172,1173,5,67,0,
        0,1173,1178,3,194,97,3,1174,1175,10,1,0,0,1175,1176,5,66,0,0,1176,
        1178,3,194,97,2,1177,1156,1,0,0,0,1177,1159,1,0,0,0,1177,1162,1,
        0,0,0,1177,1165,1,0,0,0,1177,1168,1,0,0,0,1177,1171,1,0,0,0,1177,
        1174,1,0,0,0,1178,1181,1,0,0,0,1179,1177,1,0,0,0,1179,1180,1,0,0,
        0,1180,195,1,0,0,0,1181,1179,1,0,0,0,1182,1184,5,10,0,0,1183,1182,
        1,0,0,0,1183,1184,1,0,0,0,1184,1185,1,0,0,0,1185,1189,3,198,99,0,
        1186,1188,3,204,102,0,1187,1186,1,0,0,0,1188,1191,1,0,0,0,1189,1187,
        1,0,0,0,1189,1190,1,0,0,0,1190,197,1,0,0,0,1191,1189,1,0,0,0,1192,
        1195,5,57,0,0,1193,1196,3,232,116,0,1194,1196,3,202,101,0,1195,1193,
        1,0,0,0,1195,1194,1,0,0,0,1195,1196,1,0,0,0,1196,1197,1,0,0,0,1197,
        1220,5,58,0,0,1198,1200,5,64,0,0,1199,1201,3,202,101,0,1200,1199,
        1,0,0,0,1200,1201,1,0,0,0,1201,1202,1,0,0,0,1202,1220,5,65,0,0,1203,
        1205,5,77,0,0,1204,1206,3,216,108,0,1205,1204,1,0,0,0,1205,1206,
        1,0,0,0,1206,1207,1,0,0,0,1207,1220,5,78,0,0,1208,1220,3,200,100,
        0,1209,1220,5,4,0,0,1210,1212,5,3,0,0,1211,1210,1,0,0,0,1212,1213,
        1,0,0,0,1213,1211,1,0,0,0,1213,1214,1,0,0,0,1214,1220,1,0,0,0,1215,
        1220,5,55,0,0,1216,1220,5,31,0,0,1217,1220,5,38,0,0,1218,1220,5,
        20,0,0,1219,1192,1,0,0,0,1219,1198,1,0,0,0,1219,1203,1,0,0,0,1219,
        1208,1,0,0,0,1219,1209,1,0,0,0,1219,1211,1,0,0,0,1219,1215,1,0,0,
        0,1219,1216,1,0,0,0,1219,1217,1,0,0,0,1219,1218,1,0,0,0,1220,199,
        1,0,0,0,1221,1222,7,6,0,0,1222,201,1,0,0,0,1223,1226,3,174,87,0,
        1224,1226,3,192,96,0,1225,1223,1,0,0,0,1225,1224,1,0,0,0,1226,1241,
        1,0,0,0,1227,1242,3,226,113,0,1228,1231,5,59,0,0,1229,1232,3,174,
        87,0,1230,1232,3,192,96,0,1231,1229,1,0,0,0,1231,1230,1,0,0,0,1232,
        1234,1,0,0,0,1233,1228,1,0,0,0,1234,1237,1,0,0,0,1235,1233,1,0,0,
        0,1235,1236,1,0,0,0,1236,1239,1,0,0,0,1237,1235,1,0,0,0,1238,1240,
        5,59,0,0,1239,1238,1,0,0,0,1239,1240,1,0,0,0,1240,1242,1,0,0,0,1241,
        1227,1,0,0,0,1241,1235,1,0,0,0,1242,203,1,0,0,0,1243,1245,5,57,0,
        0,1244,1246,3,220,110,0,1245,1244,1,0,0,0,1245,1246,1,0,0,0,1246,
        1247,1,0,0,0,1247,1255,5,58,0,0,1248,1249,5,64,0,0,1249,1250,3,206,
        103,0,1250,1251,5,65,0,0,1251,1255,1,0,0,0,1252,1253,5,54,0,0,1253,
        1255,3,200,100,0,1254,1243,1,0,0,0,1254,1248,1,0,0,0,1254,1252,1,
        0,0,0,1255,205,1,0,0,0,1256,1261,3,208,104,0,1257,1258,5,59,0,0,
        1258,1260,3,208,104,0,1259,1257,1,0,0,0,1260,1263,1,0,0,0,1261,1259,
        1,0,0,0,1261,1262,1,0,0,0,1262,1265,1,0,0,0,1263,1261,1,0,0,0,1264,
        1266,5,59,0,0,1265,1264,1,0,0,0,1265,1266,1,0,0,0,1266,207,1,0,0,
        0,1267,1279,3,174,87,0,1268,1270,3,174,87,0,1269,1268,1,0,0,0,1269,
        1270,1,0,0,0,1270,1271,1,0,0,0,1271,1273,5,60,0,0,1272,1274,3,174,
        87,0,1273,1272,1,0,0,0,1273,1274,1,0,0,0,1274,1276,1,0,0,0,1275,
        1277,3,210,105,0,1276,1275,1,0,0,0,1276,1277,1,0,0,0,1277,1279,1,
        0,0,0,1278,1267,1,0,0,0,1278,1269,1,0,0,0,1279,209,1,0,0,0,1280,
        1282,5,60,0,0,1281,1283,3,174,87,0,1282,1281,1,0,0,0,1282,1283,1,
        0,0,0,1283,211,1,0,0,0,1284,1287,3,194,97,0,1285,1287,3,192,96,0,
        1286,1284,1,0,0,0,1286,1285,1,0,0,0,1287,1295,1,0,0,0,1288,1291,
        5,59,0,0,1289,1292,3,194,97,0,1290,1292,3,192,96,0,1291,1289,1,0,
        0,0,1291,1290,1,0,0,0,1292,1294,1,0,0,0,1293,1288,1,0,0,0,1294,1297,
        1,0,0,0,1295,1293,1,0,0,0,1295,1296,1,0,0,0,1296,1299,1,0,0,0,1297,
        1295,1,0,0,0,1298,1300,5,59,0,0,1299,1298,1,0,0,0,1299,1300,1,0,
        0,0,1300,213,1,0,0,0,1301,1306,3,174,87,0,1302,1303,5,59,0,0,1303,
        1305,3,174,87,0,1304,1302,1,0,0,0,1305,1308,1,0,0,0,1306,1304,1,
        0,0,0,1306,1307,1,0,0,0,1307,1310,1,0,0,0,1308,1306,1,0,0,0,1309,
        1311,5,59,0,0,1310,1309,1,0,0,0,1310,1311,1,0,0,0,1311,215,1,0,0,
        0,1312,1313,3,174,87,0,1313,1314,5,60,0,0,1314,1315,3,174,87,0,1315,
        1319,1,0,0,0,1316,1317,5,62,0,0,1317,1319,3,194,97,0,1318,1312,1,
        0,0,0,1318,1316,1,0,0,0,1319,1338,1,0,0,0,1320,1339,3,226,113,0,
        1321,1328,5,59,0,0,1322,1323,3,174,87,0,1323,1324,5,60,0,0,1324,
        1325,3,174,87,0,1325,1329,1,0,0,0,1326,1327,5,62,0,0,1327,1329,3,
        194,97,0,1328,1322,1,0,0,0,1328,1326,1,0,0,0,1329,1331,1,0,0,0,1330,
        1321,1,0,0,0,1331,1334,1,0,0,0,1332,1330,1,0,0,0,1332,1333,1,0,0,
        0,1333,1336,1,0,0,0,1334,1332,1,0,0,0,1335,1337,5,59,0,0,1336,1335,
        1,0,0,0,1336,1337,1,0,0,0,1337,1339,1,0,0,0,1338,1320,1,0,0,0,1338,
        1332,1,0,0,0,1339,1361,1,0,0,0,1340,1343,3,174,87,0,1341,1343,3,
        192,96,0,1342,1340,1,0,0,0,1342,1341,1,0,0,0,1343,1358,1,0,0,0,1344,
        1359,3,226,113,0,1345,1348,5,59,0,0,1346,1349,3,174,87,0,1347,1349,
        3,192,96,0,1348,1346,1,0,0,0,1348,1347,1,0,0,0,1349,1351,1,0,0,0,
        1350,1345,1,0,0,0,1351,1354,1,0,0,0,1352,1350,1,0,0,0,1352,1353,
        1,0,0,0,1353,1356,1,0,0,0,1354,1352,1,0,0,0,1355,1357,5,59,0,0,1356,
        1355,1,0,0,0,1356,1357,1,0,0,0,1357,1359,1,0,0,0,1358,1344,1,0,0,
        0,1358,1352,1,0,0,0,1359,1361,1,0,0,0,1360,1318,1,0,0,0,1360,1342,
        1,0,0,0,1361,217,1,0,0,0,1362,1363,5,13,0,0,1363,1369,3,200,100,
        0,1364,1366,5,57,0,0,1365,1367,3,220,110,0,1366,1365,1,0,0,0,1366,
        1367,1,0,0,0,1367,1368,1,0,0,0,1368,1370,5,58,0,0,1369,1364,1,0,
        0,0,1369,1370,1,0,0,0,1370,1371,1,0,0,0,1371,1372,5,60,0,0,1372,
        1373,3,96,48,0,1373,219,1,0,0,0,1374,1379,3,222,111,0,1375,1376,
        5,59,0,0,1376,1378,3,222,111,0,1377,1375,1,0,0,0,1378,1381,1,0,0,
        0,1379,1377,1,0,0,0,1379,1380,1,0,0,0,1380,1383,1,0,0,0,1381,1379,
        1,0,0,0,1382,1384,5,59,0,0,1383,1382,1,0,0,0,1383,1384,1,0,0,0,1384,
        221,1,0,0,0,1385,1387,3,174,87,0,1386,1388,3,226,113,0,1387,1386,
        1,0,0,0,1387,1388,1,0,0,0,1388,1398,1,0,0,0,1389,1390,3,174,87,0,
        1390,1391,5,63,0,0,1391,1392,3,174,87,0,1392,1398,1,0,0,0,1393,1394,
        5,62,0,0,1394,1398,3,174,87,0,1395,1396,5,56,0,0,1396,1398,3,174,
        87,0,1397,1385,1,0,0,0,1397,1389,1,0,0,0,1397,1393,1,0,0,0,1397,
        1395,1,0,0,0,1398,223,1,0,0,0,1399,1402,3,226,113,0,1400,1402,3,
        228,114,0,1401,1399,1,0,0,0,1401,1400,1,0,0,0,1402,225,1,0,0,0,1403,
        1405,5,9,0,0,1404,1403,1,0,0,0,1404,1405,1,0,0,0,1405,1406,1,0,0,
        0,1406,1407,5,22,0,0,1407,1408,3,212,106,0,1408,1409,5,27,0,0,1409,
        1411,3,182,91,0,1410,1412,3,224,112,0,1411,1410,1,0,0,0,1411,1412,
        1,0,0,0,1412,227,1,0,0,0,1413,1414,5,25,0,0,1414,1416,3,176,88,0,
        1415,1417,3,224,112,0,1416,1415,1,0,0,0,1416,1417,1,0,0,0,1417,229,
        1,0,0,0,1418,1419,3,200,100,0,1419,231,1,0,0,0,1420,1422,5,43,0,
        0,1421,1423,3,234,117,0,1422,1421,1,0,0,0,1422,1423,1,0,0,0,1423,
        233,1,0,0,0,1424,1425,5,23,0,0,1425,1428,3,174,87,0,1426,1428,3,
        214,107,0,1427,1424,1,0,0,0,1427,1426,1,0,0,0,1428,235,1,0,0,0,1429,
        1431,5,3,0,0,1430,1429,1,0,0,0,1431,1432,1,0,0,0,1432,1430,1,0,0,
        0,1432,1433,1,0,0,0,1433,237,1,0,0,0,201,243,247,249,258,267,270,
        277,283,293,300,307,313,317,323,329,333,340,342,344,349,351,353,
        357,363,367,374,376,378,383,385,390,395,401,405,411,417,421,428,
        430,432,437,439,441,445,451,455,462,464,466,471,473,479,486,490,
        502,509,514,518,521,527,531,536,540,544,558,566,574,576,580,589,
        596,598,607,612,617,624,628,635,643,652,661,668,680,686,699,705,
        714,725,736,741,746,751,759,768,774,776,784,788,798,805,808,814,
        817,822,827,837,841,852,863,873,883,893,898,903,924,928,936,941,
        944,949,956,960,964,970,977,986,993,997,1004,1009,1025,1033,1043,
        1047,1054,1062,1075,1078,1082,1086,1093,1103,1111,1117,1125,1141,
        1151,1154,1177,1179,1183,1189,1195,1200,1205,1213,1219,1225,1231,
        1235,1239,1241,1245,1254,1261,1265,1269,1273,1276,1278,1282,1286,
        1291,1295,1299,1306,1310,1318,1328,1332,1336,1338,1342,1348,1352,
        1356,1358,1360,1366,1369,1379,1383,1387,1397,1401,1404,1411,1416,
        1422,1427,1432
    ]

class Python3Parser ( Python3ParserBase ):

    grammarFileName = "Python3Parser.g4"

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

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

    sharedContextCache = PredictionContextCache()

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

    symbolicNames = [ "<INVALID>", "INDENT", "DEDENT", "STRING", "NUMBER", 
                      "INTEGER", "AND", "AS", "ASSERT", "ASYNC", "AWAIT", 
                      "BREAK", "CASE", "CLASS", "CONTINUE", "DEF", "DEL", 
                      "ELIF", "ELSE", "EXCEPT", "FALSE", "FINALLY", "FOR", 
                      "FROM", "GLOBAL", "IF", "IMPORT", "IN", "IS", "LAMBDA", 
                      "MATCH", "NONE", "NONLOCAL", "NOT", "OR", "PASS", 
                      "RAISE", "RETURN", "TRUE", "TRY", "UNDERSCORE", "WHILE", 
                      "WITH", "YIELD", "NEWLINE", "NAME", "STRING_LITERAL", 
                      "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", 
                      "HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER", "IMAG_NUMBER", 
                      "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", "CLOSE_PAREN", 
                      "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", 
                      "OPEN_BRACK", "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", 
                      "LEFT_SHIFT", "RIGHT_SHIFT", "ADD", "MINUS", "DIV", 
                      "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", 
                      "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", 
                      "NOT_EQ_1", "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", 
                      "SUB_ASSIGN", "MULT_ASSIGN", "AT_ASSIGN", "DIV_ASSIGN", 
                      "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", 
                      "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", 
                      "IDIV_ASSIGN", "SKIP_", "UNKNOWN_CHAR" ]

    RULE_single_input = 0
    RULE_file_input = 1
    RULE_eval_input = 2
    RULE_decorator = 3
    RULE_decorators = 4
    RULE_decorated = 5
    RULE_async_funcdef = 6
    RULE_funcdef = 7
    RULE_parameters = 8
    RULE_typedargslist = 9
    RULE_tfpdef = 10
    RULE_varargslist = 11
    RULE_vfpdef = 12
    RULE_stmt = 13
    RULE_simple_stmts = 14
    RULE_simple_stmt = 15
    RULE_expr_stmt = 16
    RULE_annassign = 17
    RULE_testlist_star_expr = 18
    RULE_augassign = 19
    RULE_del_stmt = 20
    RULE_pass_stmt = 21
    RULE_flow_stmt = 22
    RULE_break_stmt = 23
    RULE_continue_stmt = 24
    RULE_return_stmt = 25
    RULE_yield_stmt = 26
    RULE_raise_stmt = 27
    RULE_import_stmt = 28
    RULE_import_name = 29
    RULE_import_from = 30
    RULE_import_as_name = 31
    RULE_dotted_as_name = 32
    RULE_import_as_names = 33
    RULE_dotted_as_names = 34
    RULE_dotted_name = 35
    RULE_global_stmt = 36
    RULE_nonlocal_stmt = 37
    RULE_assert_stmt = 38
    RULE_compound_stmt = 39
    RULE_async_stmt = 40
    RULE_if_stmt = 41
    RULE_while_stmt = 42
    RULE_for_stmt = 43
    RULE_try_stmt = 44
    RULE_with_stmt = 45
    RULE_with_item = 46
    RULE_except_clause = 47
    RULE_block = 48
    RULE_match_stmt = 49
    RULE_subject_expr = 50
    RULE_star_named_expressions = 51
    RULE_star_named_expression = 52
    RULE_case_block = 53
    RULE_guard = 54
    RULE_patterns = 55
    RULE_pattern = 56
    RULE_as_pattern = 57
    RULE_or_pattern = 58
    RULE_closed_pattern = 59
    RULE_literal_pattern = 60
    RULE_literal_expr = 61
    RULE_complex_number = 62
    RULE_signed_number = 63
    RULE_signed_real_number = 64
    RULE_real_number = 65
    RULE_imaginary_number = 66
    RULE_capture_pattern = 67
    RULE_pattern_capture_target = 68
    RULE_wildcard_pattern = 69
    RULE_value_pattern = 70
    RULE_attr = 71
    RULE_name_or_attr = 72
    RULE_group_pattern = 73
    RULE_sequence_pattern = 74
    RULE_open_sequence_pattern = 75
    RULE_maybe_sequence_pattern = 76
    RULE_maybe_star_pattern = 77
    RULE_star_pattern = 78
    RULE_mapping_pattern = 79
    RULE_items_pattern = 80
    RULE_key_value_pattern = 81
    RULE_double_star_pattern = 82
    RULE_class_pattern = 83
    RULE_positional_patterns = 84
    RULE_keyword_patterns = 85
    RULE_keyword_pattern = 86
    RULE_test = 87
    RULE_test_nocond = 88
    RULE_lambdef = 89
    RULE_lambdef_nocond = 90
    RULE_or_test = 91
    RULE_and_test = 92
    RULE_not_test = 93
    RULE_comparison = 94
    RULE_comp_op = 95
    RULE_star_expr = 96
    RULE_expr = 97
    RULE_atom_expr = 98
    RULE_atom = 99
    RULE_name = 100
    RULE_testlist_comp = 101
    RULE_trailer = 102
    RULE_subscriptlist = 103
    RULE_subscript_ = 104
    RULE_sliceop = 105
    RULE_exprlist = 106
    RULE_testlist = 107
    RULE_dictorsetmaker = 108
    RULE_classdef = 109
    RULE_arglist = 110
    RULE_argument = 111
    RULE_comp_iter = 112
    RULE_comp_for = 113
    RULE_comp_if = 114
    RULE_encoding_decl = 115
    RULE_yield_expr = 116
    RULE_yield_arg = 117
    RULE_strings = 118

    ruleNames =  [ "single_input", "file_input", "eval_input", "decorator", 
                   "decorators", "decorated", "async_funcdef", "funcdef", 
                   "parameters", "typedargslist", "tfpdef", "varargslist", 
                   "vfpdef", "stmt", "simple_stmts", "simple_stmt", "expr_stmt", 
                   "annassign", "testlist_star_expr", "augassign", "del_stmt", 
                   "pass_stmt", "flow_stmt", "break_stmt", "continue_stmt", 
                   "return_stmt", "yield_stmt", "raise_stmt", "import_stmt", 
                   "import_name", "import_from", "import_as_name", "dotted_as_name", 
                   "import_as_names", "dotted_as_names", "dotted_name", 
                   "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt", 
                   "async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt", 
                   "with_stmt", "with_item", "except_clause", "block", "match_stmt", 
                   "subject_expr", "star_named_expressions", "star_named_expression", 
                   "case_block", "guard", "patterns", "pattern", "as_pattern", 
                   "or_pattern", "closed_pattern", "literal_pattern", "literal_expr", 
                   "complex_number", "signed_number", "signed_real_number", 
                   "real_number", "imaginary_number", "capture_pattern", 
                   "pattern_capture_target", "wildcard_pattern", "value_pattern", 
                   "attr", "name_or_attr", "group_pattern", "sequence_pattern", 
                   "open_sequence_pattern", "maybe_sequence_pattern", "maybe_star_pattern", 
                   "star_pattern", "mapping_pattern", "items_pattern", "key_value_pattern", 
                   "double_star_pattern", "class_pattern", "positional_patterns", 
                   "keyword_patterns", "keyword_pattern", "test", "test_nocond", 
                   "lambdef", "lambdef_nocond", "or_test", "and_test", "not_test", 
                   "comparison", "comp_op", "star_expr", "expr", "atom_expr", 
                   "atom", "name", "testlist_comp", "trailer", "subscriptlist", 
                   "subscript_", "sliceop", "exprlist", "testlist", "dictorsetmaker", 
                   "classdef", "arglist", "argument", "comp_iter", "comp_for", 
                   "comp_if", "encoding_decl", "yield_expr", "yield_arg", 
                   "strings" ]

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

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




    class Single_inputContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NEWLINE(self):
            return self.getToken(Python3Parser.NEWLINE, 0)

        def simple_stmts(self):
            return self.getTypedRuleContext(Python3Parser.Simple_stmtsContext,0)


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


        def getRuleIndex(self):
            return Python3Parser.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 single_input(self):

        localctx = Python3Parser.Single_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_single_input)
        try:
            self.state = 243
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 238
                self.match(Python3Parser.NEWLINE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 239
                self.simple_stmts()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 240
                self.compound_stmt()
                self.state = 241
                self.match(Python3Parser.NEWLINE)
                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):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 file_input(self):

        localctx = Python3Parser.File_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_file_input)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 249
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 252271930291384088) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 4206977) != 0):
                self.state = 247
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [44]:
                    self.state = 245
                    self.match(Python3Parser.NEWLINE)
                    pass
                elif token in [3, 4, 8, 9, 10, 11, 13, 14, 15, 16, 20, 22, 23, 24, 25, 26, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 55, 56, 57, 64, 71, 72, 76, 77, 86]:
                    self.state = 246
                    self.stmt()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 251
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 252
            self.match(Python3Parser.EOF)
        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):
        __slots__ = 'parser'

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

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


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

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

        def getRuleIndex(self):
            return Python3Parser.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 eval_input(self):

        localctx = Python3Parser.Eval_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_eval_input)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 254
            self.testlist()
            self.state = 258
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==44:
                self.state = 255
                self.match(Python3Parser.NEWLINE)
                self.state = 260
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 261
            self.match(Python3Parser.EOF)
        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):
        __slots__ = 'parser'

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

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

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


        def NEWLINE(self):
            return self.getToken(Python3Parser.NEWLINE, 0)

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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 decorator(self):

        localctx = Python3Parser.DecoratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_decorator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 263
            self.match(Python3Parser.AT)
            self.state = 264
            self.dotted_name()
            self.state = 270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==57:
                self.state = 265
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 267
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4863924168670839832) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 266
                    self.arglist()


                self.state = 269
                self.match(Python3Parser.CLOSE_PAREN)


            self.state = 272
            self.match(Python3Parser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DecoratorsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_decorators

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

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




    def decorators(self):

        localctx = Python3Parser.DecoratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_decorators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 275 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 274
                self.decorator()
                self.state = 277 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==86):
                    break

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


    class DecoratedContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def decorators(self):
            return self.getTypedRuleContext(Python3Parser.DecoratorsContext,0)


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


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


        def async_funcdef(self):
            return self.getTypedRuleContext(Python3Parser.Async_funcdefContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_decorated

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

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




    def decorated(self):

        localctx = Python3Parser.DecoratedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_decorated)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 279
            self.decorators()
            self.state = 283
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [13]:
                self.state = 280
                self.classdef()
                pass
            elif token in [15]:
                self.state = 281
                self.funcdef()
                pass
            elif token in [9]:
                self.state = 282
                self.async_funcdef()
                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 Async_funcdefContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_async_funcdef

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

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




    def async_funcdef(self):

        localctx = Python3Parser.Async_funcdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_async_funcdef)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 285
            self.match(Python3Parser.ASYNC)
            self.state = 286
            self.funcdef()
        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):
        __slots__ = 'parser'

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

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

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


        def parameters(self):
            return self.getTypedRuleContext(Python3Parser.ParametersContext,0)


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

        def block(self):
            return self.getTypedRuleContext(Python3Parser.BlockContext,0)


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

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


        def getRuleIndex(self):
            return Python3Parser.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 funcdef(self):

        localctx = Python3Parser.FuncdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_funcdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 288
            self.match(Python3Parser.DEF)
            self.state = 289
            self.name()
            self.state = 290
            self.parameters()
            self.state = 293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==87:
                self.state = 291
                self.match(Python3Parser.ARROW)
                self.state = 292
                self.test()


            self.state = 295
            self.match(Python3Parser.COLON)
            self.state = 296
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_parameters

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

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




    def parameters(self):

        localctx = Python3Parser.ParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_parameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.match(Python3Parser.OPEN_PAREN)
            self.state = 300
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4683779897422774272) != 0):
                self.state = 299
                self.typedargslist()


            self.state = 302
            self.match(Python3Parser.CLOSE_PAREN)
        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):
        __slots__ = 'parser'

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

        def tfpdef(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.TfpdefContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TfpdefContext,i)


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

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

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

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


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

        def getRuleIndex(self):
            return Python3Parser.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 typedargslist(self):

        localctx = Python3Parser.TypedargslistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_typedargslist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 385
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [30, 40, 45]:
                self.state = 304
                self.tfpdef()
                self.state = 307
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63:
                    self.state = 305
                    self.match(Python3Parser.ASSIGN)
                    self.state = 306
                    self.test()


                self.state = 317
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 309
                        self.match(Python3Parser.COMMA)
                        self.state = 310
                        self.tfpdef()
                        self.state = 313
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==63:
                            self.state = 311
                            self.match(Python3Parser.ASSIGN)
                            self.state = 312
                            self.test()

                 
                    self.state = 319
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

                self.state = 353
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 320
                    self.match(Python3Parser.COMMA)
                    self.state = 351
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [56]:
                        self.state = 321
                        self.match(Python3Parser.STAR)
                        self.state = 323
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 36284957458432) != 0):
                            self.state = 322
                            self.tfpdef()


                        self.state = 333
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 325
                                self.match(Python3Parser.COMMA)
                                self.state = 326
                                self.tfpdef()
                                self.state = 329
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                if _la==63:
                                    self.state = 327
                                    self.match(Python3Parser.ASSIGN)
                                    self.state = 328
                                    self.test()

                         
                            self.state = 335
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,15,self._ctx)

                        self.state = 344
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==59:
                            self.state = 336
                            self.match(Python3Parser.COMMA)
                            self.state = 342
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if _la==62:
                                self.state = 337
                                self.match(Python3Parser.POWER)
                                self.state = 338
                                self.tfpdef()
                                self.state = 340
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                if _la==59:
                                    self.state = 339
                                    self.match(Python3Parser.COMMA)






                        pass
                    elif token in [62]:
                        self.state = 346
                        self.match(Python3Parser.POWER)
                        self.state = 347
                        self.tfpdef()
                        self.state = 349
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==59:
                            self.state = 348
                            self.match(Python3Parser.COMMA)


                        pass
                    elif token in [58]:
                        pass
                    else:
                        pass


                pass
            elif token in [56]:
                self.state = 355
                self.match(Python3Parser.STAR)
                self.state = 357
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 36284957458432) != 0):
                    self.state = 356
                    self.tfpdef()


                self.state = 367
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,24,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 359
                        self.match(Python3Parser.COMMA)
                        self.state = 360
                        self.tfpdef()
                        self.state = 363
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==63:
                            self.state = 361
                            self.match(Python3Parser.ASSIGN)
                            self.state = 362
                            self.test()

                 
                    self.state = 369
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,24,self._ctx)

                self.state = 378
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 370
                    self.match(Python3Parser.COMMA)
                    self.state = 376
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==62:
                        self.state = 371
                        self.match(Python3Parser.POWER)
                        self.state = 372
                        self.tfpdef()
                        self.state = 374
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==59:
                            self.state = 373
                            self.match(Python3Parser.COMMA)






                pass
            elif token in [62]:
                self.state = 380
                self.match(Python3Parser.POWER)
                self.state = 381
                self.tfpdef()
                self.state = 383
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 382
                    self.match(Python3Parser.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 TfpdefContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_tfpdef

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

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




    def tfpdef(self):

        localctx = Python3Parser.TfpdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_tfpdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 387
            self.name()
            self.state = 390
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==60:
                self.state = 388
                self.match(Python3Parser.COLON)
                self.state = 389
                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 VarargslistContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def vfpdef(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.VfpdefContext)
            else:
                return self.getTypedRuleContext(Python3Parser.VfpdefContext,i)


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

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

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

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


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

        def getRuleIndex(self):
            return Python3Parser.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 varargslist(self):

        localctx = Python3Parser.VarargslistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_varargslist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [30, 40, 45]:
                self.state = 392
                self.vfpdef()
                self.state = 395
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==63:
                    self.state = 393
                    self.match(Python3Parser.ASSIGN)
                    self.state = 394
                    self.test()


                self.state = 405
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 397
                        self.match(Python3Parser.COMMA)
                        self.state = 398
                        self.vfpdef()
                        self.state = 401
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==63:
                            self.state = 399
                            self.match(Python3Parser.ASSIGN)
                            self.state = 400
                            self.test()

                 
                    self.state = 407
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,33,self._ctx)

                self.state = 441
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 408
                    self.match(Python3Parser.COMMA)
                    self.state = 439
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [56]:
                        self.state = 409
                        self.match(Python3Parser.STAR)
                        self.state = 411
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 36284957458432) != 0):
                            self.state = 410
                            self.vfpdef()


                        self.state = 421
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 413
                                self.match(Python3Parser.COMMA)
                                self.state = 414
                                self.vfpdef()
                                self.state = 417
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                if _la==63:
                                    self.state = 415
                                    self.match(Python3Parser.ASSIGN)
                                    self.state = 416
                                    self.test()

                         
                            self.state = 423
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

                        self.state = 432
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==59:
                            self.state = 424
                            self.match(Python3Parser.COMMA)
                            self.state = 430
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if _la==62:
                                self.state = 425
                                self.match(Python3Parser.POWER)
                                self.state = 426
                                self.vfpdef()
                                self.state = 428
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                if _la==59:
                                    self.state = 427
                                    self.match(Python3Parser.COMMA)






                        pass
                    elif token in [62]:
                        self.state = 434
                        self.match(Python3Parser.POWER)
                        self.state = 435
                        self.vfpdef()
                        self.state = 437
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==59:
                            self.state = 436
                            self.match(Python3Parser.COMMA)


                        pass
                    elif token in [60]:
                        pass
                    else:
                        pass


                pass
            elif token in [56]:
                self.state = 443
                self.match(Python3Parser.STAR)
                self.state = 445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 36284957458432) != 0):
                    self.state = 444
                    self.vfpdef()


                self.state = 455
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 447
                        self.match(Python3Parser.COMMA)
                        self.state = 448
                        self.vfpdef()
                        self.state = 451
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==63:
                            self.state = 449
                            self.match(Python3Parser.ASSIGN)
                            self.state = 450
                            self.test()

                 
                    self.state = 457
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,45,self._ctx)

                self.state = 466
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 458
                    self.match(Python3Parser.COMMA)
                    self.state = 464
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==62:
                        self.state = 459
                        self.match(Python3Parser.POWER)
                        self.state = 460
                        self.vfpdef()
                        self.state = 462
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==59:
                            self.state = 461
                            self.match(Python3Parser.COMMA)






                pass
            elif token in [62]:
                self.state = 468
                self.match(Python3Parser.POWER)
                self.state = 469
                self.vfpdef()
                self.state = 471
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 470
                    self.match(Python3Parser.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 VfpdefContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_vfpdef

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

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




    def vfpdef(self):

        localctx = Python3Parser.VfpdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_vfpdef)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 475
            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 StmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_stmts(self):
            return self.getTypedRuleContext(Python3Parser.Simple_stmtsContext,0)


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


        def getRuleIndex(self):
            return Python3Parser.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 stmt(self):

        localctx = Python3Parser.StmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_stmt)
        try:
            self.state = 479
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 477
                self.simple_stmts()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 478
                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 Simple_stmtsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Simple_stmtContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Simple_stmtContext,i)


        def NEWLINE(self):
            return self.getToken(Python3Parser.NEWLINE, 0)

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

        def getRuleIndex(self):
            return Python3Parser.RULE_simple_stmts

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

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




    def simple_stmts(self):

        localctx = Python3Parser.Simple_stmtsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_simple_stmts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 481
            self.simple_stmt()
            self.state = 486
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,52,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 482
                    self.match(Python3Parser.SEMI_COLON)
                    self.state = 483
                    self.simple_stmt() 
                self.state = 488
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,52,self._ctx)

            self.state = 490
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==61:
                self.state = 489
                self.match(Python3Parser.SEMI_COLON)


            self.state = 492
            self.match(Python3Parser.NEWLINE)
        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):
        __slots__ = 'parser'

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

        def expr_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Expr_stmtContext,0)


        def del_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Del_stmtContext,0)


        def pass_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Pass_stmtContext,0)


        def flow_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Flow_stmtContext,0)


        def import_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Import_stmtContext,0)


        def global_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Global_stmtContext,0)


        def nonlocal_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Nonlocal_stmtContext,0)


        def assert_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Assert_stmtContext,0)


        def getRuleIndex(self):
            return Python3Parser.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 simple_stmt(self):

        localctx = Python3Parser.Simple_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_simple_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 502
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 56, 57, 64, 71, 72, 76, 77]:
                self.state = 494
                self.expr_stmt()
                pass
            elif token in [16]:
                self.state = 495
                self.del_stmt()
                pass
            elif token in [35]:
                self.state = 496
                self.pass_stmt()
                pass
            elif token in [11, 14, 36, 37, 43]:
                self.state = 497
                self.flow_stmt()
                pass
            elif token in [23, 26]:
                self.state = 498
                self.import_stmt()
                pass
            elif token in [24]:
                self.state = 499
                self.global_stmt()
                pass
            elif token in [32]:
                self.state = 500
                self.nonlocal_stmt()
                pass
            elif token in [8]:
                self.state = 501
                self.assert_stmt()
                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 Expr_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def annassign(self):
            return self.getTypedRuleContext(Python3Parser.AnnassignContext,0)


        def augassign(self):
            return self.getTypedRuleContext(Python3Parser.AugassignContext,0)


        def yield_expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Yield_exprContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Yield_exprContext,i)


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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_expr_stmt

        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 expr_stmt(self):

        localctx = Python3Parser.Expr_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_expr_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 504
            self.testlist_star_expr()
            self.state = 521
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [60]:
                self.state = 505
                self.annassign()
                pass
            elif token in [88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]:
                self.state = 506
                self.augassign()
                self.state = 509
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [43]:
                    self.state = 507
                    self.yield_expr()
                    pass
                elif token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                    self.state = 508
                    self.testlist()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [44, 61, 63]:
                self.state = 518
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==63:
                    self.state = 511
                    self.match(Python3Parser.ASSIGN)
                    self.state = 514
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [43]:
                        self.state = 512
                        self.yield_expr()
                        pass
                    elif token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 56, 57, 64, 71, 72, 76, 77]:
                        self.state = 513
                        self.testlist_star_expr()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 520
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                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 AnnassignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_annassign

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

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




    def annassign(self):

        localctx = Python3Parser.AnnassignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_annassign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 523
            self.match(Python3Parser.COLON)
            self.state = 524
            self.test()
            self.state = 527
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==63:
                self.state = 525
                self.match(Python3Parser.ASSIGN)
                self.state = 526
                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 Testlist_star_exprContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.TestContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TestContext,i)


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


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

        def getRuleIndex(self):
            return Python3Parser.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 testlist_star_expr(self):

        localctx = Python3Parser.Testlist_star_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_testlist_star_expr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.state = 529
                self.test()
                pass
            elif token in [56]:
                self.state = 530
                self.star_expr()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 540
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 533
                    self.match(Python3Parser.COMMA)
                    self.state = 536
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                        self.state = 534
                        self.test()
                        pass
                    elif token in [56]:
                        self.state = 535
                        self.star_expr()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 542
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,62,self._ctx)

            self.state = 544
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 543
                self.match(Python3Parser.COMMA)


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


    class AugassignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_augassign

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

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




    def augassign(self):

        localctx = Python3Parser.AugassignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_augassign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            _la = self._input.LA(1)
            if not(((((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & 8191) != 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 Del_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DEL(self):
            return self.getToken(Python3Parser.DEL, 0)

        def exprlist(self):
            return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_del_stmt

        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 del_stmt(self):

        localctx = Python3Parser.Del_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_del_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 548
            self.match(Python3Parser.DEL)
            self.state = 549
            self.exprlist()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pass_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_pass_stmt

        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 pass_stmt(self):

        localctx = Python3Parser.Pass_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_pass_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.match(Python3Parser.PASS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Flow_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def break_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Break_stmtContext,0)


        def continue_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Continue_stmtContext,0)


        def return_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Return_stmtContext,0)


        def raise_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Raise_stmtContext,0)


        def yield_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Yield_stmtContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_flow_stmt

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

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




    def flow_stmt(self):

        localctx = Python3Parser.Flow_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_flow_stmt)
        try:
            self.state = 558
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [11]:
                self.enterOuterAlt(localctx, 1)
                self.state = 553
                self.break_stmt()
                pass
            elif token in [14]:
                self.enterOuterAlt(localctx, 2)
                self.state = 554
                self.continue_stmt()
                pass
            elif token in [37]:
                self.enterOuterAlt(localctx, 3)
                self.state = 555
                self.return_stmt()
                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 4)
                self.state = 556
                self.raise_stmt()
                pass
            elif token in [43]:
                self.enterOuterAlt(localctx, 5)
                self.state = 557
                self.yield_stmt()
                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 Break_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_break_stmt

        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 break_stmt(self):

        localctx = Python3Parser.Break_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_break_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            self.match(Python3Parser.BREAK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Continue_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_continue_stmt

        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 continue_stmt(self):

        localctx = Python3Parser.Continue_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_continue_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 562
            self.match(Python3Parser.CONTINUE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RETURN(self):
            return self.getToken(Python3Parser.RETURN, 0)

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


        def getRuleIndex(self):
            return Python3Parser.RULE_return_stmt

        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 return_stmt(self):

        localctx = Python3Parser.Return_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_return_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 564
            self.match(Python3Parser.RETURN)
            self.state = 566
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556205523992) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                self.state = 565
                self.testlist()


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


    class Yield_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_yield_stmt

        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 yield_stmt(self):

        localctx = Python3Parser.Yield_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_yield_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self.yield_expr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Raise_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RAISE(self):
            return self.getToken(Python3Parser.RAISE, 0)

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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_raise_stmt

        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 raise_stmt(self):

        localctx = Python3Parser.Raise_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_raise_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 570
            self.match(Python3Parser.RAISE)
            self.state = 576
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556205523992) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                self.state = 571
                self.test()
                self.state = 574
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==23:
                    self.state = 572
                    self.match(Python3Parser.FROM)
                    self.state = 573
                    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 Import_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def import_name(self):
            return self.getTypedRuleContext(Python3Parser.Import_nameContext,0)


        def import_from(self):
            return self.getTypedRuleContext(Python3Parser.Import_fromContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_import_stmt

        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 import_stmt(self):

        localctx = Python3Parser.Import_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_import_stmt)
        try:
            self.state = 580
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [26]:
                self.enterOuterAlt(localctx, 1)
                self.state = 578
                self.import_name()
                pass
            elif token in [23]:
                self.enterOuterAlt(localctx, 2)
                self.state = 579
                self.import_from()
                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 Import_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IMPORT(self):
            return self.getToken(Python3Parser.IMPORT, 0)

        def dotted_as_names(self):
            return self.getTypedRuleContext(Python3Parser.Dotted_as_namesContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_import_name

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

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




    def import_name(self):

        localctx = Python3Parser.Import_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_import_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 582
            self.match(Python3Parser.IMPORT)
            self.state = 583
            self.dotted_as_names()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Import_fromContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def IMPORT(self):
            return self.getToken(Python3Parser.IMPORT, 0)

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


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

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

        def import_as_names(self):
            return self.getTypedRuleContext(Python3Parser.Import_as_namesContext,0)


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

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_import_from

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

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




    def import_from(self):

        localctx = Python3Parser.Import_fromContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_import_from)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 585
            self.match(Python3Parser.FROM)
            self.state = 598
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 589
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==54 or _la==55:
                    self.state = 586
                    _la = self._input.LA(1)
                    if not(_la==54 or _la==55):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 591
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 592
                self.dotted_name()
                pass

            elif la_ == 2:
                self.state = 594 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 593
                    _la = self._input.LA(1)
                    if not(_la==54 or _la==55):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 596 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==54 or _la==55):
                        break

                pass


            self.state = 600
            self.match(Python3Parser.IMPORT)
            self.state = 607
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.state = 601
                self.match(Python3Parser.STAR)
                pass
            elif token in [57]:
                self.state = 602
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 603
                self.import_as_names()
                self.state = 604
                self.match(Python3Parser.CLOSE_PAREN)
                pass
            elif token in [30, 40, 45]:
                self.state = 606
                self.import_as_names()
                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 Import_as_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.NameContext)
            else:
                return self.getTypedRuleContext(Python3Parser.NameContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 import_as_name(self):

        localctx = Python3Parser.Import_as_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_import_as_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 609
            self.name()
            self.state = 612
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 610
                self.match(Python3Parser.AS)
                self.state = 611
                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_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return Python3Parser.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 dotted_as_name(self):

        localctx = Python3Parser.Dotted_as_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_dotted_as_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 614
            self.dotted_name()
            self.state = 617
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 615
                self.match(Python3Parser.AS)
                self.state = 616
                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 Import_as_namesContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.Import_as_nameContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Import_as_nameContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 import_as_names(self):

        localctx = Python3Parser.Import_as_namesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_import_as_names)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 619
            self.import_as_name()
            self.state = 624
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,75,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 620
                    self.match(Python3Parser.COMMA)
                    self.state = 621
                    self.import_as_name() 
                self.state = 626
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,75,self._ctx)

            self.state = 628
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 627
                self.match(Python3Parser.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_as_namesContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.Dotted_as_nameContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Dotted_as_nameContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 dotted_as_names(self):

        localctx = Python3Parser.Dotted_as_namesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_dotted_as_names)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 630
            self.dotted_as_name()
            self.state = 635
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==59:
                self.state = 631
                self.match(Python3Parser.COMMA)
                self.state = 632
                self.dotted_as_name()
                self.state = 637
                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_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.NameContext)
            else:
                return self.getTypedRuleContext(Python3Parser.NameContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 dotted_name(self):

        localctx = Python3Parser.Dotted_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_dotted_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 638
            self.name()
            self.state = 643
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==54:
                self.state = 639
                self.match(Python3Parser.DOT)
                self.state = 640
                self.name()
                self.state = 645
                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 Global_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GLOBAL(self):
            return self.getToken(Python3Parser.GLOBAL, 0)

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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_global_stmt

        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 global_stmt(self):

        localctx = Python3Parser.Global_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_global_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 646
            self.match(Python3Parser.GLOBAL)
            self.state = 647
            self.name()
            self.state = 652
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==59:
                self.state = 648
                self.match(Python3Parser.COMMA)
                self.state = 649
                self.name()
                self.state = 654
                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 Nonlocal_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NONLOCAL(self):
            return self.getToken(Python3Parser.NONLOCAL, 0)

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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_nonlocal_stmt

        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 nonlocal_stmt(self):

        localctx = Python3Parser.Nonlocal_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_nonlocal_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 655
            self.match(Python3Parser.NONLOCAL)
            self.state = 656
            self.name()
            self.state = 661
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==59:
                self.state = 657
                self.match(Python3Parser.COMMA)
                self.state = 658
                self.name()
                self.state = 663
                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 Assert_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ASSERT(self):
            return self.getToken(Python3Parser.ASSERT, 0)

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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_assert_stmt

        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 assert_stmt(self):

        localctx = Python3Parser.Assert_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_assert_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 664
            self.match(Python3Parser.ASSERT)
            self.state = 665
            self.test()
            self.state = 668
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 666
                self.match(Python3Parser.COMMA)
                self.state = 667
                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 Compound_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def if_stmt(self):
            return self.getTypedRuleContext(Python3Parser.If_stmtContext,0)


        def while_stmt(self):
            return self.getTypedRuleContext(Python3Parser.While_stmtContext,0)


        def for_stmt(self):
            return self.getTypedRuleContext(Python3Parser.For_stmtContext,0)


        def try_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Try_stmtContext,0)


        def with_stmt(self):
            return self.getTypedRuleContext(Python3Parser.With_stmtContext,0)


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


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


        def decorated(self):
            return self.getTypedRuleContext(Python3Parser.DecoratedContext,0)


        def async_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Async_stmtContext,0)


        def match_stmt(self):
            return self.getTypedRuleContext(Python3Parser.Match_stmtContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_compound_stmt

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

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




    def compound_stmt(self):

        localctx = Python3Parser.Compound_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_compound_stmt)
        try:
            self.state = 680
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [25]:
                self.enterOuterAlt(localctx, 1)
                self.state = 670
                self.if_stmt()
                pass
            elif token in [41]:
                self.enterOuterAlt(localctx, 2)
                self.state = 671
                self.while_stmt()
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 3)
                self.state = 672
                self.for_stmt()
                pass
            elif token in [39]:
                self.enterOuterAlt(localctx, 4)
                self.state = 673
                self.try_stmt()
                pass
            elif token in [42]:
                self.enterOuterAlt(localctx, 5)
                self.state = 674
                self.with_stmt()
                pass
            elif token in [15]:
                self.enterOuterAlt(localctx, 6)
                self.state = 675
                self.funcdef()
                pass
            elif token in [13]:
                self.enterOuterAlt(localctx, 7)
                self.state = 676
                self.classdef()
                pass
            elif token in [86]:
                self.enterOuterAlt(localctx, 8)
                self.state = 677
                self.decorated()
                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 9)
                self.state = 678
                self.async_stmt()
                pass
            elif token in [30]:
                self.enterOuterAlt(localctx, 10)
                self.state = 679
                self.match_stmt()
                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 Async_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def with_stmt(self):
            return self.getTypedRuleContext(Python3Parser.With_stmtContext,0)


        def for_stmt(self):
            return self.getTypedRuleContext(Python3Parser.For_stmtContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_async_stmt

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

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




    def async_stmt(self):

        localctx = Python3Parser.Async_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_async_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 682
            self.match(Python3Parser.ASYNC)
            self.state = 686
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [15]:
                self.state = 683
                self.funcdef()
                pass
            elif token in [42]:
                self.state = 684
                self.with_stmt()
                pass
            elif token in [22]:
                self.state = 685
                self.for_stmt()
                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 If_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.BlockContext)
            else:
                return self.getTypedRuleContext(Python3Parser.BlockContext,i)


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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_if_stmt

        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 if_stmt(self):

        localctx = Python3Parser.If_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_if_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 688
            self.match(Python3Parser.IF)
            self.state = 689
            self.test()
            self.state = 690
            self.match(Python3Parser.COLON)
            self.state = 691
            self.block()
            self.state = 699
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==17:
                self.state = 692
                self.match(Python3Parser.ELIF)
                self.state = 693
                self.test()
                self.state = 694
                self.match(Python3Parser.COLON)
                self.state = 695
                self.block()
                self.state = 701
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 705
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==18:
                self.state = 702
                self.match(Python3Parser.ELSE)
                self.state = 703
                self.match(Python3Parser.COLON)
                self.state = 704
                self.block()


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


    class While_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHILE(self):
            return self.getToken(Python3Parser.WHILE, 0)

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


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

        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.BlockContext)
            else:
                return self.getTypedRuleContext(Python3Parser.BlockContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_while_stmt

        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 while_stmt(self):

        localctx = Python3Parser.While_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_while_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 707
            self.match(Python3Parser.WHILE)
            self.state = 708
            self.test()
            self.state = 709
            self.match(Python3Parser.COLON)
            self.state = 710
            self.block()
            self.state = 714
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==18:
                self.state = 711
                self.match(Python3Parser.ELSE)
                self.state = 712
                self.match(Python3Parser.COLON)
                self.state = 713
                self.block()


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


    class For_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(Python3Parser.FOR, 0)

        def exprlist(self):
            return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)


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

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


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

        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.BlockContext)
            else:
                return self.getTypedRuleContext(Python3Parser.BlockContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_for_stmt

        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 for_stmt(self):

        localctx = Python3Parser.For_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_for_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 716
            self.match(Python3Parser.FOR)
            self.state = 717
            self.exprlist()
            self.state = 718
            self.match(Python3Parser.IN)
            self.state = 719
            self.testlist()
            self.state = 720
            self.match(Python3Parser.COLON)
            self.state = 721
            self.block()
            self.state = 725
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==18:
                self.state = 722
                self.match(Python3Parser.ELSE)
                self.state = 723
                self.match(Python3Parser.COLON)
                self.state = 724
                self.block()


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


    class Try_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TRY(self):
            return self.getToken(Python3Parser.TRY, 0)

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

        def block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.BlockContext)
            else:
                return self.getTypedRuleContext(Python3Parser.BlockContext,i)


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

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


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

        def getRuleIndex(self):
            return Python3Parser.RULE_try_stmt

        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 try_stmt(self):

        localctx = Python3Parser.Try_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_try_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 727
            self.match(Python3Parser.TRY)
            self.state = 728
            self.match(Python3Parser.COLON)
            self.state = 729
            self.block()
            self.state = 751
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [19]:
                self.state = 734 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 730
                    self.except_clause()
                    self.state = 731
                    self.match(Python3Parser.COLON)
                    self.state = 732
                    self.block()
                    self.state = 736 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==19):
                        break

                self.state = 741
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==18:
                    self.state = 738
                    self.match(Python3Parser.ELSE)
                    self.state = 739
                    self.match(Python3Parser.COLON)
                    self.state = 740
                    self.block()


                self.state = 746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==21:
                    self.state = 743
                    self.match(Python3Parser.FINALLY)
                    self.state = 744
                    self.match(Python3Parser.COLON)
                    self.state = 745
                    self.block()


                pass
            elif token in [21]:
                self.state = 748
                self.match(Python3Parser.FINALLY)
                self.state = 749
                self.match(Python3Parser.COLON)
                self.state = 750
                self.block()
                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 With_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WITH(self):
            return self.getToken(Python3Parser.WITH, 0)

        def with_item(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.With_itemContext)
            else:
                return self.getTypedRuleContext(Python3Parser.With_itemContext,i)


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

        def block(self):
            return self.getTypedRuleContext(Python3Parser.BlockContext,0)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_with_stmt

        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 with_stmt(self):

        localctx = Python3Parser.With_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_with_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 753
            self.match(Python3Parser.WITH)
            self.state = 754
            self.with_item()
            self.state = 759
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==59:
                self.state = 755
                self.match(Python3Parser.COMMA)
                self.state = 756
                self.with_item()
                self.state = 761
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 762
            self.match(Python3Parser.COLON)
            self.state = 763
            self.block()
        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):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return Python3Parser.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 with_item(self):

        localctx = Python3Parser.With_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_with_item)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 765
            self.test()
            self.state = 768
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==7:
                self.state = 766
                self.match(Python3Parser.AS)
                self.state = 767
                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):
        __slots__ = 'parser'

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

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

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


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

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


        def getRuleIndex(self):
            return Python3Parser.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 except_clause(self):

        localctx = Python3Parser.Except_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_except_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 770
            self.match(Python3Parser.EXCEPT)
            self.state = 776
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556205523992) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                self.state = 771
                self.test()
                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==7:
                    self.state = 772
                    self.match(Python3Parser.AS)
                    self.state = 773
                    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 BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_stmts(self):
            return self.getTypedRuleContext(Python3Parser.Simple_stmtsContext,0)


        def NEWLINE(self):
            return self.getToken(Python3Parser.NEWLINE, 0)

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

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_block

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

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




    def block(self):

        localctx = Python3Parser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.state = 788
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 8, 10, 11, 14, 16, 20, 23, 24, 26, 29, 30, 31, 32, 33, 35, 36, 37, 38, 40, 43, 45, 55, 56, 57, 64, 71, 72, 76, 77]:
                self.enterOuterAlt(localctx, 1)
                self.state = 778
                self.simple_stmts()
                pass
            elif token in [44]:
                self.enterOuterAlt(localctx, 2)
                self.state = 779
                self.match(Python3Parser.NEWLINE)
                self.state = 780
                self.match(Python3Parser.INDENT)
                self.state = 782 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 781
                    self.stmt()
                    self.state = 784 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 252254338105339672) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 4206977) != 0)):
                        break

                self.state = 786
                self.match(Python3Parser.DEDENT)
                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 Match_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MATCH(self):
            return self.getToken(Python3Parser.MATCH, 0)

        def subject_expr(self):
            return self.getTypedRuleContext(Python3Parser.Subject_exprContext,0)


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

        def NEWLINE(self):
            return self.getToken(Python3Parser.NEWLINE, 0)

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

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

        def case_block(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Case_blockContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Case_blockContext,i)


        def getRuleIndex(self):
            return Python3Parser.RULE_match_stmt

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

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




    def match_stmt(self):

        localctx = Python3Parser.Match_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_match_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 790
            self.match(Python3Parser.MATCH)
            self.state = 791
            self.subject_expr()
            self.state = 792
            self.match(Python3Parser.COLON)
            self.state = 793
            self.match(Python3Parser.NEWLINE)
            self.state = 794
            self.match(Python3Parser.INDENT)
            self.state = 796 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 795
                self.case_block()
                self.state = 798 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==12):
                    break

            self.state = 800
            self.match(Python3Parser.DEDENT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Subject_exprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def star_named_expression(self):
            return self.getTypedRuleContext(Python3Parser.Star_named_expressionContext,0)


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

        def star_named_expressions(self):
            return self.getTypedRuleContext(Python3Parser.Star_named_expressionsContext,0)


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


        def getRuleIndex(self):
            return Python3Parser.RULE_subject_expr

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

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




    def subject_expr(self):

        localctx = Python3Parser.Subject_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_subject_expr)
        self._la = 0 # Token type
        try:
            self.state = 808
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 802
                self.star_named_expression()
                self.state = 803
                self.match(Python3Parser.COMMA)
                self.state = 805
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 804
                    self.star_named_expressions()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 807
                self.test()
                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_named_expressionsContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.COMMA)
            else:
                return self.getToken(Python3Parser.COMMA, i)

        def star_named_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Star_named_expressionContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Star_named_expressionContext,i)


        def getRuleIndex(self):
            return Python3Parser.RULE_star_named_expressions

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

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




    def star_named_expressions(self):

        localctx = Python3Parser.Star_named_expressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_star_named_expressions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 810
            self.match(Python3Parser.COMMA)
            self.state = 812 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 811
                self.star_named_expression()
                self.state = 814 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 252238150243451928) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0)):
                    break

            self.state = 817
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 816
                self.match(Python3Parser.COMMA)


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


    class Star_named_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


        def getRuleIndex(self):
            return Python3Parser.RULE_star_named_expression

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

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




    def star_named_expression(self):

        localctx = Python3Parser.Star_named_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_star_named_expression)
        try:
            self.state = 822
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 819
                self.match(Python3Parser.STAR)
                self.state = 820
                self.expr(0)
                pass
            elif token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.enterOuterAlt(localctx, 2)
                self.state = 821
                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 Case_blockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CASE(self):
            return self.getToken(Python3Parser.CASE, 0)

        def patterns(self):
            return self.getTypedRuleContext(Python3Parser.PatternsContext,0)


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

        def block(self):
            return self.getTypedRuleContext(Python3Parser.BlockContext,0)


        def guard(self):
            return self.getTypedRuleContext(Python3Parser.GuardContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_case_block

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

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




    def case_block(self):

        localctx = Python3Parser.Case_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_case_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 824
            self.match(Python3Parser.CASE)
            self.state = 825
            self.patterns()
            self.state = 827
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==25:
                self.state = 826
                self.guard()


            self.state = 829
            self.match(Python3Parser.COLON)
            self.state = 830
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GuardContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_guard

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

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




    def guard(self):

        localctx = Python3Parser.GuardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_guard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 832
            self.match(Python3Parser.IF)
            self.state = 833
            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 PatternsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def open_sequence_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Open_sequence_patternContext,0)


        def pattern(self):
            return self.getTypedRuleContext(Python3Parser.PatternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_patterns

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

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




    def patterns(self):

        localctx = Python3Parser.PatternsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_patterns)
        try:
            self.state = 837
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,105,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 835
                self.open_sequence_pattern()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 836
                self.pattern()
                pass


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


    class PatternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def as_pattern(self):
            return self.getTypedRuleContext(Python3Parser.As_patternContext,0)


        def or_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Or_patternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_pattern

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

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




    def pattern(self):

        localctx = Python3Parser.PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_pattern)
        try:
            self.state = 841
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 839
                self.as_pattern()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 840
                self.or_pattern()
                pass


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


    class As_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def or_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Or_patternContext,0)


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

        def pattern_capture_target(self):
            return self.getTypedRuleContext(Python3Parser.Pattern_capture_targetContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_as_pattern

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

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




    def as_pattern(self):

        localctx = Python3Parser.As_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_as_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 843
            self.or_pattern()
            self.state = 844
            self.match(Python3Parser.AS)
            self.state = 845
            self.pattern_capture_target()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Or_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def closed_pattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Closed_patternContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Closed_patternContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_or_pattern

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

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




    def or_pattern(self):

        localctx = Python3Parser.Or_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_or_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 847
            self.closed_pattern()
            self.state = 852
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==66:
                self.state = 848
                self.match(Python3Parser.OR_OP)
                self.state = 849
                self.closed_pattern()
                self.state = 854
                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 Closed_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def literal_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Literal_patternContext,0)


        def capture_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Capture_patternContext,0)


        def wildcard_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Wildcard_patternContext,0)


        def value_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Value_patternContext,0)


        def group_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Group_patternContext,0)


        def sequence_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Sequence_patternContext,0)


        def mapping_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Mapping_patternContext,0)


        def class_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Class_patternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_closed_pattern

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

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




    def closed_pattern(self):

        localctx = Python3Parser.Closed_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_closed_pattern)
        try:
            self.state = 863
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 855
                self.literal_pattern()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 856
                self.capture_pattern()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 857
                self.wildcard_pattern()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 858
                self.value_pattern()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 859
                self.group_pattern()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 860
                self.sequence_pattern()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 861
                self.mapping_pattern()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 862
                self.class_pattern()
                pass


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


    class Literal_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def signed_number(self):
            return self.getTypedRuleContext(Python3Parser.Signed_numberContext,0)


        def complex_number(self):
            return self.getTypedRuleContext(Python3Parser.Complex_numberContext,0)


        def strings(self):
            return self.getTypedRuleContext(Python3Parser.StringsContext,0)


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

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_literal_pattern

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

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




    def literal_pattern(self):

        localctx = Python3Parser.Literal_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_literal_pattern)
        try:
            self.state = 873
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,109,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 865
                self.signed_number()
                self.state = 866
                if not  self.CannotBePlusMinus() :
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, " self.CannotBePlusMinus() ")
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 868
                self.complex_number()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 869
                self.strings()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 870
                self.match(Python3Parser.NONE)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 871
                self.match(Python3Parser.TRUE)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 872
                self.match(Python3Parser.FALSE)
                pass


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


    class Literal_exprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def signed_number(self):
            return self.getTypedRuleContext(Python3Parser.Signed_numberContext,0)


        def complex_number(self):
            return self.getTypedRuleContext(Python3Parser.Complex_numberContext,0)


        def strings(self):
            return self.getTypedRuleContext(Python3Parser.StringsContext,0)


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

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_literal_expr

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

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




    def literal_expr(self):

        localctx = Python3Parser.Literal_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_literal_expr)
        try:
            self.state = 883
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 875
                self.signed_number()
                self.state = 876
                if not  self.CannotBePlusMinus() :
                    from antlr4.error.Errors import FailedPredicateException
                    raise FailedPredicateException(self, " self.CannotBePlusMinus() ")
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 878
                self.complex_number()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 879
                self.strings()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 880
                self.match(Python3Parser.NONE)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 881
                self.match(Python3Parser.TRUE)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 882
                self.match(Python3Parser.FALSE)
                pass


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


    class Complex_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def signed_real_number(self):
            return self.getTypedRuleContext(Python3Parser.Signed_real_numberContext,0)


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

        def imaginary_number(self):
            return self.getTypedRuleContext(Python3Parser.Imaginary_numberContext,0)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_complex_number

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

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




    def complex_number(self):

        localctx = Python3Parser.Complex_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_complex_number)
        try:
            self.state = 893
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 885
                self.signed_real_number()
                self.state = 886
                self.match(Python3Parser.ADD)
                self.state = 887
                self.imaginary_number()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 889
                self.signed_real_number()
                self.state = 890
                self.match(Python3Parser.MINUS)
                self.state = 891
                self.imaginary_number()
                pass


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


    class Signed_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NUMBER(self):
            return self.getToken(Python3Parser.NUMBER, 0)

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

        def getRuleIndex(self):
            return Python3Parser.RULE_signed_number

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

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




    def signed_number(self):

        localctx = Python3Parser.Signed_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_signed_number)
        try:
            self.state = 898
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 895
                self.match(Python3Parser.NUMBER)
                pass
            elif token in [72]:
                self.enterOuterAlt(localctx, 2)
                self.state = 896
                self.match(Python3Parser.MINUS)
                self.state = 897
                self.match(Python3Parser.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 Signed_real_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def real_number(self):
            return self.getTypedRuleContext(Python3Parser.Real_numberContext,0)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_signed_real_number

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

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




    def signed_real_number(self):

        localctx = Python3Parser.Signed_real_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_signed_real_number)
        try:
            self.state = 903
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [4]:
                self.enterOuterAlt(localctx, 1)
                self.state = 900
                self.real_number()
                pass
            elif token in [72]:
                self.enterOuterAlt(localctx, 2)
                self.state = 901
                self.match(Python3Parser.MINUS)
                self.state = 902
                self.real_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 Real_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NUMBER(self):
            return self.getToken(Python3Parser.NUMBER, 0)

        def getRuleIndex(self):
            return Python3Parser.RULE_real_number

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

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




    def real_number(self):

        localctx = Python3Parser.Real_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_real_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 905
            self.match(Python3Parser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Imaginary_numberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NUMBER(self):
            return self.getToken(Python3Parser.NUMBER, 0)

        def getRuleIndex(self):
            return Python3Parser.RULE_imaginary_number

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

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




    def imaginary_number(self):

        localctx = Python3Parser.Imaginary_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_imaginary_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 907
            self.match(Python3Parser.NUMBER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Capture_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pattern_capture_target(self):
            return self.getTypedRuleContext(Python3Parser.Pattern_capture_targetContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_capture_pattern

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

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




    def capture_pattern(self):

        localctx = Python3Parser.Capture_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_capture_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 909
            self.pattern_capture_target()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pattern_capture_targetContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_pattern_capture_target

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

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




    def pattern_capture_target(self):

        localctx = Python3Parser.Pattern_capture_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_pattern_capture_target)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 911
            self.name()
            self.state = 912
            if not  self.CannotBeDotLpEq() :
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, " self.CannotBeDotLpEq() ")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Wildcard_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNDERSCORE(self):
            return self.getToken(Python3Parser.UNDERSCORE, 0)

        def getRuleIndex(self):
            return Python3Parser.RULE_wildcard_pattern

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

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




    def wildcard_pattern(self):

        localctx = Python3Parser.Wildcard_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_wildcard_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 914
            self.match(Python3Parser.UNDERSCORE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Value_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def attr(self):
            return self.getTypedRuleContext(Python3Parser.AttrContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_value_pattern

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

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




    def value_pattern(self):

        localctx = Python3Parser.Value_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_value_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 916
            self.attr()
            self.state = 917
            if not  self.CannotBeDotLpEq() :
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, " self.CannotBeDotLpEq() ")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttrContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.NameContext)
            else:
                return self.getTypedRuleContext(Python3Parser.NameContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_attr

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

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




    def attr(self):

        localctx = Python3Parser.AttrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_attr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 919
            self.name()
            self.state = 922 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 920
                    self.match(Python3Parser.DOT)
                    self.state = 921
                    self.name()

                else:
                    raise NoViableAltException(self)
                self.state = 924 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,114,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 Name_or_attrContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def attr(self):
            return self.getTypedRuleContext(Python3Parser.AttrContext,0)


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


        def getRuleIndex(self):
            return Python3Parser.RULE_name_or_attr

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

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




    def name_or_attr(self):

        localctx = Python3Parser.Name_or_attrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_name_or_attr)
        try:
            self.state = 928
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 926
                self.attr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 927
                self.name()
                pass


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


    class Group_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def pattern(self):
            return self.getTypedRuleContext(Python3Parser.PatternContext,0)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_group_pattern

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

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




    def group_pattern(self):

        localctx = Python3Parser.Group_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_group_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 930
            self.match(Python3Parser.OPEN_PAREN)
            self.state = 931
            self.pattern()
            self.state = 932
            self.match(Python3Parser.CLOSE_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sequence_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_BRACK(self):
            return self.getToken(Python3Parser.OPEN_BRACK, 0)

        def CLOSE_BRACK(self):
            return self.getToken(Python3Parser.CLOSE_BRACK, 0)

        def maybe_sequence_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Maybe_sequence_patternContext,0)


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

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

        def open_sequence_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Open_sequence_patternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_sequence_pattern

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

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




    def sequence_pattern(self):

        localctx = Python3Parser.Sequence_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_sequence_pattern)
        self._la = 0 # Token type
        try:
            self.state = 944
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [64]:
                self.enterOuterAlt(localctx, 1)
                self.state = 934
                self.match(Python3Parser.OPEN_BRACK)
                self.state = 936
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 216209344097681432) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 8449) != 0):
                    self.state = 935
                    self.maybe_sequence_pattern()


                self.state = 938
                self.match(Python3Parser.CLOSE_BRACK)
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 2)
                self.state = 939
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 941
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 216209344097681432) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 8449) != 0):
                    self.state = 940
                    self.open_sequence_pattern()


                self.state = 943
                self.match(Python3Parser.CLOSE_PAREN)
                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 Open_sequence_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def maybe_star_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Maybe_star_patternContext,0)


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

        def maybe_sequence_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Maybe_sequence_patternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_open_sequence_pattern

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

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




    def open_sequence_pattern(self):

        localctx = Python3Parser.Open_sequence_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_open_sequence_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 946
            self.maybe_star_pattern()
            self.state = 947
            self.match(Python3Parser.COMMA)
            self.state = 949
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 216209344097681432) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 8449) != 0):
                self.state = 948
                self.maybe_sequence_pattern()


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


    class Maybe_sequence_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def maybe_star_pattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Maybe_star_patternContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Maybe_star_patternContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_maybe_sequence_pattern

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

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




    def maybe_sequence_pattern(self):

        localctx = Python3Parser.Maybe_sequence_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_maybe_sequence_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 951
            self.maybe_star_pattern()
            self.state = 956
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,120,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 952
                    self.match(Python3Parser.COMMA)
                    self.state = 953
                    self.maybe_star_pattern() 
                self.state = 958
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,120,self._ctx)

            self.state = 960
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 959
                self.match(Python3Parser.COMMA)


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


    class Maybe_star_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def star_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Star_patternContext,0)


        def pattern(self):
            return self.getTypedRuleContext(Python3Parser.PatternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_maybe_star_pattern

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

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




    def maybe_star_pattern(self):

        localctx = Python3Parser.Maybe_star_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_maybe_star_pattern)
        try:
            self.state = 964
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 962
                self.star_pattern()
                pass
            elif token in [3, 4, 20, 30, 31, 38, 40, 45, 57, 64, 72, 77]:
                self.enterOuterAlt(localctx, 2)
                self.state = 963
                self.pattern()
                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 Star_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def pattern_capture_target(self):
            return self.getTypedRuleContext(Python3Parser.Pattern_capture_targetContext,0)


        def wildcard_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Wildcard_patternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_star_pattern

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

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




    def star_pattern(self):

        localctx = Python3Parser.Star_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_star_pattern)
        try:
            self.state = 970
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 966
                self.match(Python3Parser.STAR)
                self.state = 967
                self.pattern_capture_target()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 968
                self.match(Python3Parser.STAR)
                self.state = 969
                self.wildcard_pattern()
                pass


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


    class Mapping_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def double_star_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Double_star_patternContext,0)


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

        def items_pattern(self):
            return self.getTypedRuleContext(Python3Parser.Items_patternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_mapping_pattern

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

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




    def mapping_pattern(self):

        localctx = Python3Parser.Mapping_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_mapping_pattern)
        self._la = 0 # Token type
        try:
            self.state = 997
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,127,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 972
                self.match(Python3Parser.OPEN_BRACE)
                self.state = 973
                self.match(Python3Parser.CLOSE_BRACE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 974
                self.match(Python3Parser.OPEN_BRACE)
                self.state = 975
                self.double_star_pattern()
                self.state = 977
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 976
                    self.match(Python3Parser.COMMA)


                self.state = 979
                self.match(Python3Parser.CLOSE_BRACE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 981
                self.match(Python3Parser.OPEN_BRACE)
                self.state = 982
                self.items_pattern()
                self.state = 983
                self.match(Python3Parser.COMMA)
                self.state = 984
                self.double_star_pattern()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 985
                    self.match(Python3Parser.COMMA)


                self.state = 988
                self.match(Python3Parser.CLOSE_BRACE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 990
                self.match(Python3Parser.OPEN_BRACE)
                self.state = 991
                self.items_pattern()
                self.state = 993
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 992
                    self.match(Python3Parser.COMMA)


                self.state = 995
                self.match(Python3Parser.CLOSE_BRACE)
                pass


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


    class Items_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def key_value_pattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Key_value_patternContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Key_value_patternContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_items_pattern

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

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




    def items_pattern(self):

        localctx = Python3Parser.Items_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_items_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 999
            self.key_value_pattern()
            self.state = 1004
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,128,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1000
                    self.match(Python3Parser.COMMA)
                    self.state = 1001
                    self.key_value_pattern() 
                self.state = 1006
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,128,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 Key_value_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def pattern(self):
            return self.getTypedRuleContext(Python3Parser.PatternContext,0)


        def literal_expr(self):
            return self.getTypedRuleContext(Python3Parser.Literal_exprContext,0)


        def attr(self):
            return self.getTypedRuleContext(Python3Parser.AttrContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_key_value_pattern

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

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




    def key_value_pattern(self):

        localctx = Python3Parser.Key_value_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_key_value_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1009
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 20, 31, 38, 72]:
                self.state = 1007
                self.literal_expr()
                pass
            elif token in [30, 40, 45]:
                self.state = 1008
                self.attr()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1011
            self.match(Python3Parser.COLON)
            self.state = 1012
            self.pattern()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Double_star_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def pattern_capture_target(self):
            return self.getTypedRuleContext(Python3Parser.Pattern_capture_targetContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_double_star_pattern

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

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




    def double_star_pattern(self):

        localctx = Python3Parser.Double_star_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_double_star_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1014
            self.match(Python3Parser.POWER)
            self.state = 1015
            self.pattern_capture_target()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def name_or_attr(self):
            return self.getTypedRuleContext(Python3Parser.Name_or_attrContext,0)


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

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

        def positional_patterns(self):
            return self.getTypedRuleContext(Python3Parser.Positional_patternsContext,0)


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

        def keyword_patterns(self):
            return self.getTypedRuleContext(Python3Parser.Keyword_patternsContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_class_pattern

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

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




    def class_pattern(self):

        localctx = Python3Parser.Class_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_class_pattern)
        self._la = 0 # Token type
        try:
            self.state = 1047
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1017
                self.name_or_attr()
                self.state = 1018
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1019
                self.match(Python3Parser.CLOSE_PAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1021
                self.name_or_attr()
                self.state = 1022
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1023
                self.positional_patterns()
                self.state = 1025
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 1024
                    self.match(Python3Parser.COMMA)


                self.state = 1027
                self.match(Python3Parser.CLOSE_PAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1029
                self.name_or_attr()
                self.state = 1030
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1031
                self.keyword_patterns()
                self.state = 1033
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 1032
                    self.match(Python3Parser.COMMA)


                self.state = 1035
                self.match(Python3Parser.CLOSE_PAREN)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1037
                self.name_or_attr()
                self.state = 1038
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1039
                self.positional_patterns()
                self.state = 1040
                self.match(Python3Parser.COMMA)
                self.state = 1041
                self.keyword_patterns()
                self.state = 1043
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 1042
                    self.match(Python3Parser.COMMA)


                self.state = 1045
                self.match(Python3Parser.CLOSE_PAREN)
                pass


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


    class Positional_patternsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def pattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.PatternContext)
            else:
                return self.getTypedRuleContext(Python3Parser.PatternContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_positional_patterns

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

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




    def positional_patterns(self):

        localctx = Python3Parser.Positional_patternsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_positional_patterns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1049
            self.pattern()
            self.state = 1054
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,134,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1050
                    self.match(Python3Parser.COMMA)
                    self.state = 1051
                    self.pattern() 
                self.state = 1056
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,134,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 Keyword_patternsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def keyword_pattern(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Keyword_patternContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Keyword_patternContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_keyword_patterns

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

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




    def keyword_patterns(self):

        localctx = Python3Parser.Keyword_patternsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_keyword_patterns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1057
            self.keyword_pattern()
            self.state = 1062
            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 = 1058
                    self.match(Python3Parser.COMMA)
                    self.state = 1059
                    self.keyword_pattern() 
                self.state = 1064
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,135,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 Keyword_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def pattern(self):
            return self.getTypedRuleContext(Python3Parser.PatternContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_keyword_pattern

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

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




    def keyword_pattern(self):

        localctx = Python3Parser.Keyword_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_keyword_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1065
            self.name()
            self.state = 1066
            self.match(Python3Parser.ASSIGN)
            self.state = 1067
            self.pattern()
        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):
        __slots__ = 'parser'

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

        def or_test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Or_testContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Or_testContext,i)


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

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

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


        def lambdef(self):
            return self.getTypedRuleContext(Python3Parser.LambdefContext,0)


        def getRuleIndex(self):
            return Python3Parser.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 test(self):

        localctx = Python3Parser.TestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_test)
        self._la = 0 # Token type
        try:
            self.state = 1078
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1069
                self.or_test()
                self.state = 1075
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==25:
                    self.state = 1070
                    self.match(Python3Parser.IF)
                    self.state = 1071
                    self.or_test()
                    self.state = 1072
                    self.match(Python3Parser.ELSE)
                    self.state = 1073
                    self.test()


                pass
            elif token in [29]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1077
                self.lambdef()
                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 Test_nocondContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def or_test(self):
            return self.getTypedRuleContext(Python3Parser.Or_testContext,0)


        def lambdef_nocond(self):
            return self.getTypedRuleContext(Python3Parser.Lambdef_nocondContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_test_nocond

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

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




    def test_nocond(self):

        localctx = Python3Parser.Test_nocondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_test_nocond)
        try:
            self.state = 1082
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1080
                self.or_test()
                pass
            elif token in [29]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1081
                self.lambdef_nocond()
                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 LambdefContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def getRuleIndex(self):
            return Python3Parser.RULE_lambdef

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

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




    def lambdef(self):

        localctx = Python3Parser.LambdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_lambdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1084
            self.match(Python3Parser.LAMBDA)
            self.state = 1086
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4683779897422774272) != 0):
                self.state = 1085
                self.varargslist()


            self.state = 1088
            self.match(Python3Parser.COLON)
            self.state = 1089
            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 Lambdef_nocondContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def test_nocond(self):
            return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0)


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


        def getRuleIndex(self):
            return Python3Parser.RULE_lambdef_nocond

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

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




    def lambdef_nocond(self):

        localctx = Python3Parser.Lambdef_nocondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_lambdef_nocond)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1091
            self.match(Python3Parser.LAMBDA)
            self.state = 1093
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4683779897422774272) != 0):
                self.state = 1092
                self.varargslist()


            self.state = 1095
            self.match(Python3Parser.COLON)
            self.state = 1096
            self.test_nocond()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Or_testContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def and_test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.And_testContext)
            else:
                return self.getTypedRuleContext(Python3Parser.And_testContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_or_test

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

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




    def or_test(self):

        localctx = Python3Parser.Or_testContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_or_test)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1098
            self.and_test()
            self.state = 1103
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==34:
                self.state = 1099
                self.match(Python3Parser.OR)
                self.state = 1100
                self.and_test()
                self.state = 1105
                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 And_testContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def not_test(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Not_testContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Not_testContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.RULE_and_test

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

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




    def and_test(self):

        localctx = Python3Parser.And_testContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_and_test)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1106
            self.not_test()
            self.state = 1111
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==6:
                self.state = 1107
                self.match(Python3Parser.AND)
                self.state = 1108
                self.not_test()
                self.state = 1113
                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 Not_testContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def not_test(self):
            return self.getTypedRuleContext(Python3Parser.Not_testContext,0)


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


        def getRuleIndex(self):
            return Python3Parser.RULE_not_test

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

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




    def not_test(self):

        localctx = Python3Parser.Not_testContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_not_test)
        try:
            self.state = 1117
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [33]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1114
                self.match(Python3Parser.NOT)
                self.state = 1115
                self.not_test()
                pass
            elif token in [3, 4, 10, 20, 30, 31, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1116
                self.comparison()
                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 ComparisonContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.ExprContext)
            else:
                return self.getTypedRuleContext(Python3Parser.ExprContext,i)


        def comp_op(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(Python3Parser.Comp_opContext)
            else:
                return self.getTypedRuleContext(Python3Parser.Comp_opContext,i)


        def getRuleIndex(self):
            return Python3Parser.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 comparison(self):

        localctx = Python3Parser.ComparisonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_comparison)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1119
            self.expr(0)
            self.state = 1125
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,144,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1120
                    self.comp_op()
                    self.state = 1121
                    self.expr(0) 
                self.state = 1127
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,144,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 Comp_opContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_comp_op

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

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




    def comp_op(self):

        localctx = Python3Parser.Comp_opContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_comp_op)
        try:
            self.state = 1141
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1128
                self.match(Python3Parser.LESS_THAN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1129
                self.match(Python3Parser.GREATER_THAN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1130
                self.match(Python3Parser.EQUALS)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1131
                self.match(Python3Parser.GT_EQ)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1132
                self.match(Python3Parser.LT_EQ)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1133
                self.match(Python3Parser.NOT_EQ_1)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1134
                self.match(Python3Parser.NOT_EQ_2)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1135
                self.match(Python3Parser.IN)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1136
                self.match(Python3Parser.NOT)
                self.state = 1137
                self.match(Python3Parser.IN)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1138
                self.match(Python3Parser.IS)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1139
                self.match(Python3Parser.IS)
                self.state = 1140
                self.match(Python3Parser.NOT)
                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):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 star_expr(self):

        localctx = Python3Parser.Star_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_star_expr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1143
            self.match(Python3Parser.STAR)
            self.state = 1144
            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 ExprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def atom_expr(self):
            return self.getTypedRuleContext(Python3Parser.Atom_exprContext,0)


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return Python3Parser.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 expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = Python3Parser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 194
        self.enterRecursionRule(localctx, 194, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1154
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 30, 31, 38, 40, 45, 55, 57, 64, 77]:
                self.state = 1147
                self.atom_expr()
                pass
            elif token in [71, 72, 76]:
                self.state = 1149 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1148
                        _la = self._input.LA(1)
                        if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & 35) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()

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

                self.state = 1153
                self.expr(7)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 1179
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,149,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 = 1177
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
                    if la_ == 1:
                        localctx = Python3Parser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1156
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1157
                        self.match(Python3Parser.POWER)
                        self.state = 1158
                        self.expr(9)
                        pass

                    elif la_ == 2:
                        localctx = Python3Parser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1159
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1160
                        _la = self._input.LA(1)
                        if not(((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & 1074659329) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1161
                        self.expr(7)
                        pass

                    elif la_ == 3:
                        localctx = Python3Parser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1162
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1163
                        _la = self._input.LA(1)
                        if not(_la==71 or _la==72):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1164
                        self.expr(6)
                        pass

                    elif la_ == 4:
                        localctx = Python3Parser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1165
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1166
                        _la = self._input.LA(1)
                        if not(_la==69 or _la==70):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1167
                        self.expr(5)
                        pass

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

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

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

             
                self.state = 1181
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,149,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 Atom_exprContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_atom_expr

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

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




    def atom_expr(self):

        localctx = Python3Parser.Atom_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_atom_expr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1183
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 1182
                self.match(Python3Parser.AWAIT)


            self.state = 1185
            self.atom()
            self.state = 1189
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,151,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1186
                    self.trailer() 
                self.state = 1191
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,151,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 AtomContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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


        def OPEN_BRACK(self):
            return self.getToken(Python3Parser.OPEN_BRACK, 0)

        def CLOSE_BRACK(self):
            return self.getToken(Python3Parser.CLOSE_BRACK, 0)

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

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

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


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


        def NUMBER(self):
            return self.getToken(Python3Parser.NUMBER, 0)

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

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

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

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

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

        def getRuleIndex(self):
            return Python3Parser.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 atom(self):

        localctx = Python3Parser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_atom)
        self._la = 0 # Token type
        try:
            self.state = 1219
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [57]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1192
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1195
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [43]:
                    self.state = 1193
                    self.yield_expr()
                    pass
                elif token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 56, 57, 64, 71, 72, 76, 77]:
                    self.state = 1194
                    self.testlist_comp()
                    pass
                elif token in [58]:
                    pass
                else:
                    pass
                self.state = 1197
                self.match(Python3Parser.CLOSE_PAREN)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1198
                self.match(Python3Parser.OPEN_BRACK)
                self.state = 1200
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 252238150243451928) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 1199
                    self.testlist_comp()


                self.state = 1202
                self.match(Python3Parser.CLOSE_BRACK)
                pass
            elif token in [77]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1203
                self.match(Python3Parser.OPEN_BRACE)
                self.state = 1205
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4863924168670839832) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 1204
                    self.dictorsetmaker()


                self.state = 1207
                self.match(Python3Parser.CLOSE_BRACE)
                pass
            elif token in [30, 40, 45]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1208
                self.name()
                pass
            elif token in [4]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1209
                self.match(Python3Parser.NUMBER)
                pass
            elif token in [3]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1211 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1210
                        self.match(Python3Parser.STRING)

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

                pass
            elif token in [55]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1215
                self.match(Python3Parser.ELLIPSIS)
                pass
            elif token in [31]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1216
                self.match(Python3Parser.NONE)
                pass
            elif token in [38]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1217
                self.match(Python3Parser.TRUE)
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1218
                self.match(Python3Parser.FALSE)
                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 NameContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def UNDERSCORE(self):
            return self.getToken(Python3Parser.UNDERSCORE, 0)

        def MATCH(self):
            return self.getToken(Python3Parser.MATCH, 0)

        def getRuleIndex(self):
            return Python3Parser.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 name(self):

        localctx = Python3Parser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1221
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 36284957458432) != 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 Testlist_compContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.TestContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TestContext,i)


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


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


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

        def getRuleIndex(self):
            return Python3Parser.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 testlist_comp(self):

        localctx = Python3Parser.Testlist_compContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_testlist_comp)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1225
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.state = 1223
                self.test()
                pass
            elif token in [56]:
                self.state = 1224
                self.star_expr()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1241
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9, 22]:
                self.state = 1227
                self.comp_for()
                pass
            elif token in [58, 59, 65]:
                self.state = 1235
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,159,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1228
                        self.match(Python3Parser.COMMA)
                        self.state = 1231
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                            self.state = 1229
                            self.test()
                            pass
                        elif token in [56]:
                            self.state = 1230
                            self.star_expr()
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 1237
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,159,self._ctx)

                self.state = 1239
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==59:
                    self.state = 1238
                    self.match(Python3Parser.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 TrailerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def OPEN_BRACK(self):
            return self.getToken(Python3Parser.OPEN_BRACK, 0)

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


        def CLOSE_BRACK(self):
            return self.getToken(Python3Parser.CLOSE_BRACK, 0)

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

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


        def getRuleIndex(self):
            return Python3Parser.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 trailer(self):

        localctx = Python3Parser.TrailerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_trailer)
        self._la = 0 # Token type
        try:
            self.state = 1254
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [57]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1243
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1245
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4863924168670839832) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 1244
                    self.arglist()


                self.state = 1247
                self.match(Python3Parser.CLOSE_PAREN)
                pass
            elif token in [64]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1248
                self.match(Python3Parser.OPEN_BRACK)
                self.state = 1249
                self.subscriptlist()
                self.state = 1250
                self.match(Python3Parser.CLOSE_BRACK)
                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1252
                self.match(Python3Parser.DOT)
                self.state = 1253
                self.name()
                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):
        __slots__ = 'parser'

        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(Python3Parser.Subscript_Context)
            else:
                return self.getTypedRuleContext(Python3Parser.Subscript_Context,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 subscriptlist(self):

        localctx = Python3Parser.SubscriptlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_subscriptlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1256
            self.subscript_()
            self.state = 1261
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,164,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1257
                    self.match(Python3Parser.COMMA)
                    self.state = 1258
                    self.subscript_() 
                self.state = 1263
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,164,self._ctx)

            self.state = 1265
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 1264
                self.match(Python3Parser.COMMA)


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


    class Subscript_Context(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.TestContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TestContext,i)


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

        def sliceop(self):
            return self.getTypedRuleContext(Python3Parser.SliceopContext,0)


        def getRuleIndex(self):
            return Python3Parser.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 subscript_(self):

        localctx = Python3Parser.Subscript_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_subscript_)
        self._la = 0 # Token type
        try:
            self.state = 1278
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1267
                self.test()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1269
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556205523992) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 1268
                    self.test()


                self.state = 1271
                self.match(Python3Parser.COLON)
                self.state = 1273
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556205523992) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 1272
                    self.test()


                self.state = 1276
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==60:
                    self.state = 1275
                    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):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 sliceop(self):

        localctx = Python3Parser.SliceopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_sliceop)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1280
            self.match(Python3Parser.COLON)
            self.state = 1282
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556205523992) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                self.state = 1281
                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 ExprlistContext(ParserRuleContext):
        __slots__ = 'parser'

        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(Python3Parser.ExprContext)
            else:
                return self.getTypedRuleContext(Python3Parser.ExprContext,i)


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


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

        def getRuleIndex(self):
            return Python3Parser.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 exprlist(self):

        localctx = Python3Parser.ExprlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_exprlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1286
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3, 4, 10, 20, 30, 31, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.state = 1284
                self.expr(0)
                pass
            elif token in [56]:
                self.state = 1285
                self.star_expr()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1295
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,173,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1288
                    self.match(Python3Parser.COMMA)
                    self.state = 1291
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [3, 4, 10, 20, 30, 31, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                        self.state = 1289
                        self.expr(0)
                        pass
                    elif token in [56]:
                        self.state = 1290
                        self.star_expr()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1297
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,173,self._ctx)

            self.state = 1299
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 1298
                self.match(Python3Parser.COMMA)


        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):
        __slots__ = 'parser'

        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(Python3Parser.TestContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TestContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 testlist(self):

        localctx = Python3Parser.TestlistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_testlist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1301
            self.test()
            self.state = 1306
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,175,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1302
                    self.match(Python3Parser.COMMA)
                    self.state = 1303
                    self.test() 
                self.state = 1308
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,175,self._ctx)

            self.state = 1310
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 1309
                self.match(Python3Parser.COMMA)


        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):
        __slots__ = 'parser'

        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(Python3Parser.TestContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TestContext,i)


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

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

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


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


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


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

        def getRuleIndex(self):
            return Python3Parser.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 dictorsetmaker(self):

        localctx = Python3Parser.DictorsetmakerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_dictorsetmaker)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1360
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
            if la_ == 1:
                self.state = 1318
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                    self.state = 1312
                    self.test()
                    self.state = 1313
                    self.match(Python3Parser.COLON)
                    self.state = 1314
                    self.test()
                    pass
                elif token in [62]:
                    self.state = 1316
                    self.match(Python3Parser.POWER)
                    self.state = 1317
                    self.expr(0)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1338
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [9, 22]:
                    self.state = 1320
                    self.comp_for()
                    pass
                elif token in [59, 78]:
                    self.state = 1332
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,179,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1321
                            self.match(Python3Parser.COMMA)
                            self.state = 1328
                            self._errHandler.sync(self)
                            token = self._input.LA(1)
                            if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                                self.state = 1322
                                self.test()
                                self.state = 1323
                                self.match(Python3Parser.COLON)
                                self.state = 1324
                                self.test()
                                pass
                            elif token in [62]:
                                self.state = 1326
                                self.match(Python3Parser.POWER)
                                self.state = 1327
                                self.expr(0)
                                pass
                            else:
                                raise NoViableAltException(self)
                     
                        self.state = 1334
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,179,self._ctx)

                    self.state = 1336
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==59:
                        self.state = 1335
                        self.match(Python3Parser.COMMA)


                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                self.state = 1342
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                    self.state = 1340
                    self.test()
                    pass
                elif token in [56]:
                    self.state = 1341
                    self.star_expr()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1358
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [9, 22]:
                    self.state = 1344
                    self.comp_for()
                    pass
                elif token in [59, 78]:
                    self.state = 1352
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,184,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1345
                            self.match(Python3Parser.COMMA)
                            self.state = 1348
                            self._errHandler.sync(self)
                            token = self._input.LA(1)
                            if token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                                self.state = 1346
                                self.test()
                                pass
                            elif token in [56]:
                                self.state = 1347
                                self.star_expr()
                                pass
                            else:
                                raise NoViableAltException(self)
                     
                        self.state = 1354
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,184,self._ctx)

                    self.state = 1356
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==59:
                        self.state = 1355
                        self.match(Python3Parser.COMMA)


                    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 ClassdefContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def block(self):
            return self.getTypedRuleContext(Python3Parser.BlockContext,0)


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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 classdef(self):

        localctx = Python3Parser.ClassdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_classdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1362
            self.match(Python3Parser.CLASS)
            self.state = 1363
            self.name()
            self.state = 1369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==57:
                self.state = 1364
                self.match(Python3Parser.OPEN_PAREN)
                self.state = 1366
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 4863924168670839832) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                    self.state = 1365
                    self.arglist()


                self.state = 1368
                self.match(Python3Parser.CLOSE_PAREN)


            self.state = 1371
            self.match(Python3Parser.COLON)
            self.state = 1372
            self.block()
        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):
        __slots__ = 'parser'

        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(Python3Parser.ArgumentContext)
            else:
                return self.getTypedRuleContext(Python3Parser.ArgumentContext,i)


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

        def getRuleIndex(self):
            return Python3Parser.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 arglist(self):

        localctx = Python3Parser.ArglistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_arglist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1374
            self.argument()
            self.state = 1379
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,190,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1375
                    self.match(Python3Parser.COMMA)
                    self.state = 1376
                    self.argument() 
                self.state = 1381
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,190,self._ctx)

            self.state = 1383
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==59:
                self.state = 1382
                self.match(Python3Parser.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):
        __slots__ = 'parser'

        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(Python3Parser.TestContext)
            else:
                return self.getTypedRuleContext(Python3Parser.TestContext,i)


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

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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 argument(self):

        localctx = Python3Parser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_argument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1397
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,193,self._ctx)
            if la_ == 1:
                self.state = 1385
                self.test()
                self.state = 1387
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9 or _la==22:
                    self.state = 1386
                    self.comp_for()


                pass

            elif la_ == 2:
                self.state = 1389
                self.test()
                self.state = 1390
                self.match(Python3Parser.ASSIGN)
                self.state = 1391
                self.test()
                pass

            elif la_ == 3:
                self.state = 1393
                self.match(Python3Parser.POWER)
                self.state = 1394
                self.test()
                pass

            elif la_ == 4:
                self.state = 1395
                self.match(Python3Parser.STAR)
                self.state = 1396
                self.test()
                pass


        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):
        __slots__ = 'parser'

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

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


        def comp_if(self):
            return self.getTypedRuleContext(Python3Parser.Comp_ifContext,0)


        def getRuleIndex(self):
            return Python3Parser.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 comp_iter(self):

        localctx = Python3Parser.Comp_iterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_comp_iter)
        try:
            self.state = 1401
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9, 22]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1399
                self.comp_for()
                pass
            elif token in [25]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1400
                self.comp_if()
                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 Comp_forContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(Python3Parser.FOR, 0)

        def exprlist(self):
            return self.getTypedRuleContext(Python3Parser.ExprlistContext,0)


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

        def or_test(self):
            return self.getTypedRuleContext(Python3Parser.Or_testContext,0)


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

        def comp_iter(self):
            return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0)


        def getRuleIndex(self):
            return Python3Parser.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 comp_for(self):

        localctx = Python3Parser.Comp_forContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_comp_for)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1403
                self.match(Python3Parser.ASYNC)


            self.state = 1406
            self.match(Python3Parser.FOR)
            self.state = 1407
            self.exprlist()
            self.state = 1408
            self.match(Python3Parser.IN)
            self.state = 1409
            self.or_test()
            self.state = 1411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 37749248) != 0):
                self.state = 1410
                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_ifContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def test_nocond(self):
            return self.getTypedRuleContext(Python3Parser.Test_nocondContext,0)


        def comp_iter(self):
            return self.getTypedRuleContext(Python3Parser.Comp_iterContext,0)


        def getRuleIndex(self):
            return Python3Parser.RULE_comp_if

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

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




    def comp_if(self):

        localctx = Python3Parser.Comp_ifContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_comp_if)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1413
            self.match(Python3Parser.IF)
            self.state = 1414
            self.test_nocond()
            self.state = 1416
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 37749248) != 0):
                self.state = 1415
                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 Encoding_declContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return Python3Parser.RULE_encoding_decl

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

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




    def encoding_decl(self):

        localctx = Python3Parser.Encoding_declContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_encoding_decl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1418
            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 Yield_exprContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return Python3Parser.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 yield_expr(self):

        localctx = Python3Parser.Yield_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_yield_expr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1420
            self.match(Python3Parser.YIELD)
            self.state = 1422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 180180556213912600) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & 12673) != 0):
                self.state = 1421
                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):
        __slots__ = 'parser'

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

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

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


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


        def getRuleIndex(self):
            return Python3Parser.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 yield_arg(self):

        localctx = Python3Parser.Yield_argContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_yield_arg)
        try:
            self.state = 1427
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [23]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1424
                self.match(Python3Parser.FROM)
                self.state = 1425
                self.test()
                pass
            elif token in [3, 4, 10, 20, 29, 30, 31, 33, 38, 40, 45, 55, 57, 64, 71, 72, 76, 77]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1426
                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 StringsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return Python3Parser.RULE_strings

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

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




    def strings(self):

        localctx = Python3Parser.StringsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_strings)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1430 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1429
                self.match(Python3Parser.STRING)
                self.state = 1432 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==3):
                    break

        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[60] = self.literal_pattern_sempred
        self._predicates[61] = self.literal_expr_sempred
        self._predicates[68] = self.pattern_capture_target_sempred
        self._predicates[70] = self.value_pattern_sempred
        self._predicates[97] = self.expr_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 literal_pattern_sempred(self, localctx:Literal_patternContext, predIndex:int):
            if predIndex == 0:
                return  self.CannotBePlusMinus() 
         

    def literal_expr_sempred(self, localctx:Literal_exprContext, predIndex:int):
            if predIndex == 1:
                return  self.CannotBePlusMinus() 
         

    def pattern_capture_target_sempred(self, localctx:Pattern_capture_targetContext, predIndex:int):
            if predIndex == 2:
                return  self.CannotBeDotLpEq() 
         

    def value_pattern_sempred(self, localctx:Value_patternContext, predIndex:int):
            if predIndex == 3:
                return  self.CannotBeDotLpEq() 
         

    def expr_sempred(self, localctx:ExprContext, predIndex:int):
            if predIndex == 4:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 2)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 1)
         




