# Generated from PythonParser.g4 by ANTLR 4.13.2
# 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

def serializedATN():
    return [
        4,1,102,2201,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,2,119,7,119,2,120,
        7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,
        2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,
        7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,
        2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,
        7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,
        2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,
        7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,
        2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
        7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,
        2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,
        7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,
        2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,
        7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191,
        2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,1,0,3,0,394,8,0,
        1,0,1,0,1,1,1,1,1,2,1,2,5,2,402,8,2,10,2,12,2,405,9,2,1,2,1,2,1,
        3,1,3,3,3,411,8,3,1,3,1,3,1,3,1,3,5,3,417,8,3,10,3,12,3,420,9,3,
        1,3,1,3,1,4,4,4,425,8,4,11,4,12,4,426,1,5,1,5,3,5,431,8,5,1,6,1,
        6,1,6,1,6,1,6,1,6,3,6,439,8,6,1,7,1,7,1,7,5,7,444,8,7,10,7,12,7,
        447,9,7,1,7,3,7,450,8,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,1,8,1,8,
        1,8,1,8,1,8,1,8,1,8,1,8,3,8,468,8,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,
        1,9,3,9,478,8,9,1,10,1,10,1,10,1,10,1,10,3,10,485,8,10,1,10,1,10,
        1,10,1,10,1,10,3,10,492,8,10,1,10,1,10,1,10,1,10,3,10,498,8,10,1,
        10,1,10,1,10,4,10,503,8,10,11,10,12,10,504,1,10,1,10,3,10,509,8,
        10,1,10,3,10,512,8,10,1,10,1,10,1,10,1,10,3,10,518,8,10,3,10,520,
        8,10,1,11,1,11,3,11,524,8,11,1,12,1,12,1,13,1,13,3,13,530,8,13,1,
        14,1,14,1,14,1,14,3,14,536,8,14,3,14,538,8,14,1,15,1,15,1,15,1,15,
        5,15,544,8,15,10,15,12,15,547,9,15,1,16,1,16,1,16,1,16,5,16,553,
        8,16,10,16,12,16,556,9,16,1,17,1,17,1,17,1,18,1,18,1,19,1,19,1,19,
        1,19,3,19,567,8,19,1,20,1,20,3,20,571,8,20,1,21,1,21,1,21,1,22,1,
        22,5,22,578,8,22,10,22,12,22,581,9,22,1,22,1,22,1,22,1,22,1,22,1,
        22,4,22,589,8,22,11,22,12,22,590,1,22,1,22,3,22,595,8,22,1,23,1,
        23,1,23,3,23,600,8,23,1,23,1,23,1,23,1,23,3,23,606,8,23,1,24,1,24,
        1,24,5,24,611,8,24,10,24,12,24,614,9,24,1,25,1,25,1,25,3,25,619,
        8,25,1,26,1,26,1,26,5,26,624,8,26,10,26,12,26,627,9,26,1,27,1,27,
        1,27,3,27,632,8,27,1,28,1,28,1,28,1,28,1,28,1,28,5,28,640,8,28,10,
        28,12,28,643,9,28,1,29,1,29,1,29,1,29,1,29,1,29,3,29,651,8,29,1,
        30,1,30,1,30,1,30,4,30,657,8,30,11,30,12,30,658,1,31,1,31,1,31,1,
        31,3,31,665,8,31,1,32,1,32,1,32,3,32,670,8,32,1,32,1,32,3,32,674,
        8,32,1,32,3,32,677,8,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,3,33,
        686,8,33,1,34,1,34,1,34,3,34,691,8,34,1,34,1,34,3,34,695,8,34,1,
        34,1,34,1,34,3,34,700,8,34,1,34,1,34,3,34,704,8,34,1,34,1,34,1,34,
        1,34,1,34,1,34,3,34,712,8,34,1,34,1,34,3,34,716,8,34,1,34,1,34,1,
        34,3,34,721,8,34,1,34,1,34,3,34,725,8,34,1,34,1,34,3,34,729,8,34,
        1,35,1,35,1,36,1,36,5,36,735,8,36,10,36,12,36,738,9,36,1,36,5,36,
        741,8,36,10,36,12,36,744,9,36,1,36,3,36,747,8,36,1,36,1,36,5,36,
        751,8,36,10,36,12,36,754,9,36,1,36,3,36,757,8,36,1,36,4,36,760,8,
        36,11,36,12,36,761,1,36,5,36,765,8,36,10,36,12,36,768,9,36,1,36,
        3,36,771,8,36,1,36,4,36,774,8,36,11,36,12,36,775,1,36,3,36,779,8,
        36,1,36,3,36,782,8,36,1,37,4,37,785,8,37,11,37,12,37,786,1,37,1,
        37,3,37,791,8,37,1,38,5,38,794,8,38,10,38,12,38,797,9,38,1,38,4,
        38,800,8,38,11,38,12,38,801,1,38,1,38,3,38,806,8,38,1,39,1,39,1,
        39,5,39,811,8,39,10,39,12,39,814,9,39,1,39,3,39,817,8,39,1,39,1,
        39,1,39,5,39,822,8,39,10,39,12,39,825,9,39,1,39,3,39,828,8,39,1,
        39,1,39,1,39,4,39,833,8,39,11,39,12,39,834,1,39,3,39,838,8,39,1,
        39,3,39,841,8,39,1,40,1,40,1,40,1,41,1,41,3,41,848,8,41,1,41,3,41,
        851,8,41,1,42,1,42,3,42,855,8,42,1,42,3,42,858,8,42,1,43,1,43,1,
        43,3,43,863,8,43,1,43,3,43,866,8,43,1,44,1,44,3,44,870,8,44,1,44,
        3,44,873,8,44,1,44,3,44,876,8,44,1,45,1,45,3,45,880,8,45,1,46,1,
        46,1,46,1,47,1,47,1,47,1,48,1,48,1,48,1,49,1,49,1,49,1,50,1,50,1,
        50,1,50,1,50,1,50,3,50,900,8,50,3,50,902,8,50,1,51,1,51,1,51,1,51,
        1,51,1,51,3,51,910,8,51,3,51,912,8,51,1,52,1,52,1,52,1,52,1,53,1,
        53,1,53,1,53,1,53,3,53,923,8,53,1,54,3,54,926,8,54,1,54,1,54,1,54,
        1,54,1,54,1,54,3,54,934,8,54,1,54,1,54,3,54,938,8,54,1,55,1,55,1,
        55,1,55,1,55,5,55,945,8,55,10,55,12,55,948,9,55,1,55,3,55,951,8,
        55,1,55,1,55,1,55,3,55,956,8,55,1,55,1,55,1,55,1,55,1,55,1,55,1,
        55,1,55,5,55,966,8,55,10,55,12,55,969,9,55,1,55,3,55,972,8,55,1,
        55,1,55,1,55,1,55,1,55,3,55,979,8,55,1,55,1,55,1,55,1,55,5,55,985,
        8,55,10,55,12,55,988,9,55,1,55,1,55,3,55,992,8,55,1,55,1,55,3,55,
        996,8,55,1,56,1,56,1,56,3,56,1001,8,56,1,57,1,57,1,57,1,57,1,57,
        1,57,1,57,1,57,1,57,4,57,1012,8,57,11,57,12,57,1013,1,57,3,57,1017,
        8,57,1,57,3,57,1020,8,57,1,57,1,57,1,57,1,57,4,57,1026,8,57,11,57,
        12,57,1027,1,57,3,57,1031,8,57,1,57,3,57,1034,8,57,3,57,1036,8,57,
        1,58,1,58,1,58,1,58,3,58,1042,8,58,3,58,1044,8,58,1,58,1,58,1,58,
        1,59,1,59,1,59,1,59,1,59,3,59,1054,8,59,1,59,1,59,1,59,1,60,1,60,
        1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,4,61,1069,8,61,11,61,12,
        61,1070,1,61,1,61,1,62,1,62,1,62,3,62,1078,8,62,1,62,3,62,1081,8,
        62,1,63,1,63,1,63,3,63,1086,8,63,1,63,1,63,1,63,1,64,1,64,1,64,1,
        65,1,65,3,65,1096,8,65,1,66,1,66,3,66,1100,8,66,1,67,1,67,1,67,1,
        67,1,68,1,68,1,68,5,68,1109,8,68,10,68,12,68,1112,9,68,1,69,1,69,
        1,69,1,69,1,69,1,69,1,69,1,69,3,69,1122,8,69,1,70,1,70,1,70,1,70,
        1,70,1,70,3,70,1130,8,70,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1138,
        8,71,1,72,1,72,1,72,1,72,1,73,3,73,1145,8,73,1,73,1,73,1,74,3,74,
        1150,8,74,1,74,1,74,1,75,1,75,1,76,1,76,1,77,1,77,1,78,1,78,1,79,
        1,79,1,80,1,80,1,81,1,81,1,81,4,81,1169,8,81,11,81,12,81,1170,1,
        82,1,82,1,82,5,82,1176,8,82,10,82,12,82,1179,9,82,1,83,1,83,1,83,
        1,83,1,84,1,84,3,84,1187,8,84,1,84,1,84,1,84,3,84,1192,8,84,1,84,
        3,84,1195,8,84,1,85,1,85,1,85,3,85,1200,8,85,1,86,1,86,1,86,5,86,
        1205,8,86,10,86,12,86,1208,9,86,1,86,3,86,1211,8,86,1,87,1,87,3,
        87,1215,8,87,1,88,1,88,1,88,1,89,1,89,1,89,1,89,1,89,3,89,1225,8,
        89,1,89,1,89,1,89,1,89,1,89,1,89,3,89,1233,8,89,1,89,3,89,1236,8,
        89,1,89,1,89,3,89,1240,8,89,1,90,1,90,1,90,5,90,1245,8,90,10,90,
        12,90,1248,9,90,1,91,1,91,3,91,1252,8,91,1,91,1,91,1,91,1,92,1,92,
        1,92,1,93,1,93,1,93,1,93,1,93,3,93,1265,8,93,1,93,3,93,1268,8,93,
        1,93,3,93,1271,8,93,3,93,1273,8,93,1,93,1,93,1,94,1,94,1,94,5,94,
        1280,8,94,10,94,12,94,1283,9,94,1,95,1,95,1,95,5,95,1288,8,95,10,
        95,12,95,1291,9,95,1,96,1,96,1,96,1,96,1,97,1,97,1,97,3,97,1300,
        8,97,1,97,1,97,1,97,1,98,1,98,1,98,1,98,1,99,1,99,1,99,5,99,1312,
        8,99,10,99,12,99,1315,9,99,1,99,3,99,1318,8,99,1,100,1,100,3,100,
        1322,8,100,1,100,3,100,1325,8,100,1,100,1,100,1,100,3,100,1330,8,
        100,1,100,1,100,1,100,3,100,1335,8,100,3,100,1337,8,100,1,101,1,
        101,1,101,1,102,1,102,1,102,1,103,1,103,1,103,1,104,1,104,1,104,
        5,104,1351,8,104,10,104,12,104,1354,9,104,1,104,3,104,1357,8,104,
        1,105,1,105,1,105,1,105,1,105,1,105,3,105,1365,8,105,1,105,3,105,
        1368,8,105,1,106,1,106,1,106,1,106,3,106,1374,8,106,3,106,1376,8,
        106,1,107,1,107,1,107,5,107,1381,8,107,10,107,12,107,1384,9,107,
        1,107,3,107,1387,8,107,1,108,1,108,1,108,3,108,1392,8,108,1,109,
        1,109,1,109,5,109,1397,8,109,10,109,12,109,1400,9,109,1,109,3,109,
        1403,8,109,1,110,1,110,1,110,3,110,1408,8,110,1,111,1,111,1,111,
        1,111,1,112,1,112,3,112,1416,8,112,1,113,1,113,1,113,5,113,1421,
        8,113,10,113,12,113,1424,9,113,1,114,1,114,1,114,5,114,1429,8,114,
        10,114,12,114,1432,9,114,1,115,1,115,1,115,3,115,1437,8,115,1,116,
        1,116,5,116,1441,8,116,10,116,12,116,1444,9,116,1,117,1,117,1,117,
        1,117,1,117,1,117,1,117,1,117,1,117,1,117,3,117,1456,8,117,1,118,
        1,118,1,118,1,119,1,119,1,119,1,120,1,120,1,120,1,121,1,121,1,121,
        1,122,1,122,1,122,1,123,1,123,1,123,1,124,1,124,1,124,1,124,1,125,
        1,125,1,125,1,126,1,126,1,126,1,126,1,127,1,127,1,127,1,128,1,128,
        1,128,1,128,1,128,1,128,5,128,1496,8,128,10,128,12,128,1499,9,128,
        1,129,1,129,1,129,1,129,1,129,1,129,5,129,1507,8,129,10,129,12,129,
        1510,9,129,1,130,1,130,1,130,1,130,1,130,1,130,5,130,1518,8,130,
        10,130,12,130,1521,9,130,1,131,1,131,1,131,1,131,1,131,1,131,5,131,
        1529,8,131,10,131,12,131,1532,9,131,1,132,1,132,1,132,1,132,1,132,
        1,132,5,132,1540,8,132,10,132,12,132,1543,9,132,1,133,1,133,1,133,
        1,133,1,133,1,133,5,133,1551,8,133,10,133,12,133,1554,9,133,1,134,
        1,134,1,134,1,134,1,134,1,134,1,134,3,134,1563,8,134,1,135,1,135,
        1,135,3,135,1568,8,135,1,136,1,136,1,136,3,136,1573,8,136,1,137,
        1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,1584,8,137,
        1,137,1,137,1,137,1,137,1,137,3,137,1591,8,137,5,137,1593,8,137,
        10,137,12,137,1596,9,137,1,138,1,138,1,138,3,138,1601,8,138,1,138,
        1,138,1,138,3,138,1606,8,138,5,138,1608,8,138,10,138,12,138,1611,
        9,138,1,138,3,138,1614,8,138,3,138,1616,8,138,1,139,3,139,1619,8,
        139,1,139,1,139,3,139,1623,8,139,1,139,1,139,3,139,1627,8,139,3,
        139,1629,8,139,1,139,3,139,1632,8,139,1,140,1,140,1,140,1,140,1,
        140,1,140,1,140,1,140,1,140,3,140,1643,8,140,1,140,1,140,3,140,1647,
        8,140,1,140,1,140,1,140,1,140,3,140,1653,8,140,1,140,3,140,1656,
        8,140,1,141,1,141,1,141,3,141,1661,8,141,1,141,1,141,1,142,1,142,
        3,142,1667,8,142,1,142,1,142,1,142,1,143,1,143,1,144,1,144,5,144,
        1676,8,144,10,144,12,144,1679,9,144,1,144,5,144,1682,8,144,10,144,
        12,144,1685,9,144,1,144,3,144,1688,8,144,1,144,1,144,5,144,1692,
        8,144,10,144,12,144,1695,9,144,1,144,3,144,1698,8,144,1,144,4,144,
        1701,8,144,11,144,12,144,1702,1,144,5,144,1706,8,144,10,144,12,144,
        1709,9,144,1,144,3,144,1712,8,144,1,144,4,144,1715,8,144,11,144,
        12,144,1716,1,144,3,144,1720,8,144,1,144,3,144,1723,8,144,1,145,
        4,145,1726,8,145,11,145,12,145,1727,1,145,1,145,3,145,1732,8,145,
        1,146,5,146,1735,8,146,10,146,12,146,1738,9,146,1,146,4,146,1741,
        8,146,11,146,12,146,1742,1,146,1,146,3,146,1747,8,146,1,147,1,147,
        1,147,5,147,1752,8,147,10,147,12,147,1755,9,147,1,147,3,147,1758,
        8,147,1,147,1,147,1,147,4,147,1763,8,147,11,147,12,147,1764,1,147,
        3,147,1768,8,147,1,147,3,147,1771,8,147,1,148,1,148,1,148,1,149,
        1,149,3,149,1778,8,149,1,150,1,150,1,150,3,150,1783,8,150,1,151,
        1,151,3,151,1787,8,151,1,151,3,151,1790,8,151,1,152,1,152,1,153,
        1,153,3,153,1796,8,153,1,154,1,154,1,154,3,154,1801,8,154,1,154,
        3,154,1804,8,154,1,154,3,154,1807,8,154,1,154,1,154,1,155,1,155,
        1,155,1,156,1,156,5,156,1816,8,156,10,156,12,156,1819,9,156,1,157,
        1,157,3,157,1823,8,157,1,158,1,158,5,158,1827,8,158,10,158,12,158,
        1830,9,158,1,158,1,158,1,159,1,159,1,160,1,160,4,160,1838,8,160,
        11,160,12,160,1839,1,161,1,161,3,161,1844,8,161,1,161,1,161,1,162,
        1,162,1,162,1,162,3,162,1852,8,162,3,162,1854,8,162,1,162,1,162,
        1,163,1,163,1,163,1,163,1,164,1,164,3,164,1864,8,164,1,164,1,164,
        1,165,1,165,1,165,5,165,1871,8,165,10,165,12,165,1874,9,165,1,165,
        3,165,1877,8,165,1,166,1,166,1,166,3,166,1882,8,166,1,167,1,167,
        1,167,1,167,1,168,4,168,1889,8,168,11,168,12,168,1890,1,169,3,169,
        1894,8,169,1,169,1,169,1,169,1,169,1,169,1,169,5,169,1902,8,169,
        10,169,12,169,1905,9,169,1,170,1,170,1,170,1,170,1,170,1,171,1,171,
        1,171,1,171,1,171,1,172,1,172,1,172,3,172,1920,8,172,1,172,1,172,
        1,172,1,173,1,173,1,173,1,173,1,173,1,174,1,174,3,174,1932,8,174,
        1,175,1,175,1,175,3,175,1937,8,175,3,175,1939,8,175,1,175,1,175,
        1,175,1,175,3,175,1945,8,175,3,175,1947,8,175,5,175,1949,8,175,10,
        175,12,175,1952,9,175,1,175,1,175,3,175,1956,8,175,1,175,3,175,1959,
        8,175,1,176,1,176,1,176,5,176,1964,8,176,10,176,12,176,1967,9,176,
        1,176,1,176,1,176,1,176,5,176,1973,8,176,10,176,12,176,1976,9,176,
        3,176,1978,8,176,1,176,1,176,1,176,5,176,1983,8,176,10,176,12,176,
        1986,9,176,3,176,1988,8,176,1,177,1,177,1,177,1,178,1,178,1,178,
        1,178,1,178,3,178,1998,8,178,1,179,1,179,1,179,1,179,1,179,1,179,
        3,179,2006,8,179,1,180,1,180,1,180,5,180,2011,8,180,10,180,12,180,
        2014,9,180,1,180,3,180,2017,8,180,1,181,1,181,1,181,5,181,2022,8,
        181,10,181,12,181,2025,9,181,1,181,3,181,2028,8,181,1,182,1,182,
        1,182,1,182,4,182,2034,8,182,11,182,12,182,2035,1,182,3,182,2039,
        8,182,3,182,2041,8,182,1,183,1,183,1,183,3,183,2046,8,183,1,184,
        1,184,1,184,1,184,1,184,1,184,1,184,3,184,2055,8,184,1,184,3,184,
        2058,8,184,1,185,1,185,1,185,1,185,1,185,1,185,1,185,3,185,2067,
        8,185,1,185,1,185,1,185,3,185,2072,8,185,1,185,3,185,2075,8,185,
        1,186,1,186,1,186,1,186,1,186,1,186,3,186,2083,8,186,1,187,1,187,
        1,187,1,187,1,187,1,187,1,187,3,187,2092,8,187,1,188,1,188,1,188,
        1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,3,188,
        2107,8,188,1,188,3,188,2110,8,188,5,188,2112,8,188,10,188,12,188,
        2115,9,188,1,189,1,189,1,189,5,189,2120,8,189,10,189,12,189,2123,
        9,189,1,189,3,189,2126,8,189,1,190,1,190,1,190,1,190,1,190,1,190,
        1,190,3,190,2135,8,190,1,190,3,190,2138,8,190,1,191,1,191,1,191,
        1,191,1,191,1,191,1,191,3,191,2147,8,191,1,191,1,191,1,191,3,191,
        2152,8,191,1,191,3,191,2155,8,191,1,192,1,192,1,192,5,192,2160,8,
        192,10,192,12,192,2163,9,192,1,192,1,192,1,192,1,192,1,192,1,192,
        3,192,2171,8,192,1,192,1,192,3,192,2175,8,192,3,192,2177,8,192,1,
        192,1,192,1,192,1,192,1,192,3,192,2184,8,192,1,192,1,192,3,192,2188,
        8,192,1,193,1,193,1,193,3,193,2193,8,193,1,194,1,194,1,195,1,195,
        3,195,2199,8,195,1,195,0,9,56,256,258,260,262,264,266,274,376,196,
        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,238,240,242,244,246,248,250,252,
        254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284,
        286,288,290,292,294,296,298,300,302,304,306,308,310,312,314,316,
        318,320,322,324,326,328,330,332,334,336,338,340,342,344,346,348,
        350,352,354,356,358,360,362,364,366,368,370,372,374,376,378,380,
        382,384,386,388,390,0,6,3,0,37,47,49,49,51,51,2,0,14,14,53,53,1,
        0,18,19,1,0,34,35,4,0,20,21,27,27,48,48,50,50,2,0,91,93,95,95,2379,
        0,393,1,0,0,0,2,397,1,0,0,0,4,399,1,0,0,0,6,408,1,0,0,0,8,424,1,
        0,0,0,10,430,1,0,0,0,12,438,1,0,0,0,14,440,1,0,0,0,16,467,1,0,0,
        0,18,477,1,0,0,0,20,519,1,0,0,0,22,523,1,0,0,0,24,525,1,0,0,0,26,
        527,1,0,0,0,28,531,1,0,0,0,30,539,1,0,0,0,32,548,1,0,0,0,34,557,
        1,0,0,0,36,560,1,0,0,0,38,562,1,0,0,0,40,570,1,0,0,0,42,572,1,0,
        0,0,44,594,1,0,0,0,46,605,1,0,0,0,48,607,1,0,0,0,50,615,1,0,0,0,
        52,620,1,0,0,0,54,628,1,0,0,0,56,633,1,0,0,0,58,650,1,0,0,0,60,656,
        1,0,0,0,62,664,1,0,0,0,64,666,1,0,0,0,66,685,1,0,0,0,68,728,1,0,
        0,0,70,730,1,0,0,0,72,781,1,0,0,0,74,784,1,0,0,0,76,795,1,0,0,0,
        78,840,1,0,0,0,80,842,1,0,0,0,82,845,1,0,0,0,84,852,1,0,0,0,86,859,
        1,0,0,0,88,867,1,0,0,0,90,877,1,0,0,0,92,881,1,0,0,0,94,884,1,0,
        0,0,96,887,1,0,0,0,98,890,1,0,0,0,100,893,1,0,0,0,102,903,1,0,0,
        0,104,913,1,0,0,0,106,917,1,0,0,0,108,925,1,0,0,0,110,995,1,0,0,
        0,112,997,1,0,0,0,114,1035,1,0,0,0,116,1037,1,0,0,0,118,1048,1,0,
        0,0,120,1058,1,0,0,0,122,1062,1,0,0,0,124,1080,1,0,0,0,126,1082,
        1,0,0,0,128,1090,1,0,0,0,130,1095,1,0,0,0,132,1099,1,0,0,0,134,1101,
        1,0,0,0,136,1105,1,0,0,0,138,1121,1,0,0,0,140,1129,1,0,0,0,142,1137,
        1,0,0,0,144,1139,1,0,0,0,146,1144,1,0,0,0,148,1149,1,0,0,0,150,1153,
        1,0,0,0,152,1155,1,0,0,0,154,1157,1,0,0,0,156,1159,1,0,0,0,158,1161,
        1,0,0,0,160,1163,1,0,0,0,162,1165,1,0,0,0,164,1172,1,0,0,0,166,1180,
        1,0,0,0,168,1194,1,0,0,0,170,1196,1,0,0,0,172,1201,1,0,0,0,174,1214,
        1,0,0,0,176,1216,1,0,0,0,178,1239,1,0,0,0,180,1241,1,0,0,0,182,1251,
        1,0,0,0,184,1256,1,0,0,0,186,1259,1,0,0,0,188,1276,1,0,0,0,190,1284,
        1,0,0,0,192,1292,1,0,0,0,194,1296,1,0,0,0,196,1304,1,0,0,0,198,1308,
        1,0,0,0,200,1336,1,0,0,0,202,1338,1,0,0,0,204,1341,1,0,0,0,206,1344,
        1,0,0,0,208,1347,1,0,0,0,210,1367,1,0,0,0,212,1369,1,0,0,0,214,1377,
        1,0,0,0,216,1391,1,0,0,0,218,1393,1,0,0,0,220,1407,1,0,0,0,222,1409,
        1,0,0,0,224,1415,1,0,0,0,226,1417,1,0,0,0,228,1425,1,0,0,0,230,1436,
        1,0,0,0,232,1438,1,0,0,0,234,1455,1,0,0,0,236,1457,1,0,0,0,238,1460,
        1,0,0,0,240,1463,1,0,0,0,242,1466,1,0,0,0,244,1469,1,0,0,0,246,1472,
        1,0,0,0,248,1475,1,0,0,0,250,1479,1,0,0,0,252,1482,1,0,0,0,254,1486,
        1,0,0,0,256,1489,1,0,0,0,258,1500,1,0,0,0,260,1511,1,0,0,0,262,1522,
        1,0,0,0,264,1533,1,0,0,0,266,1544,1,0,0,0,268,1562,1,0,0,0,270,1564,
        1,0,0,0,272,1572,1,0,0,0,274,1574,1,0,0,0,276,1615,1,0,0,0,278,1631,
        1,0,0,0,280,1655,1,0,0,0,282,1657,1,0,0,0,284,1664,1,0,0,0,286,1671,
        1,0,0,0,288,1722,1,0,0,0,290,1725,1,0,0,0,292,1736,1,0,0,0,294,1770,
        1,0,0,0,296,1772,1,0,0,0,298,1775,1,0,0,0,300,1779,1,0,0,0,302,1784,
        1,0,0,0,304,1791,1,0,0,0,306,1795,1,0,0,0,308,1797,1,0,0,0,310,1810,
        1,0,0,0,312,1813,1,0,0,0,314,1822,1,0,0,0,316,1824,1,0,0,0,318,1833,
        1,0,0,0,320,1837,1,0,0,0,322,1841,1,0,0,0,324,1847,1,0,0,0,326,1857,
        1,0,0,0,328,1861,1,0,0,0,330,1867,1,0,0,0,332,1881,1,0,0,0,334,1883,
        1,0,0,0,336,1888,1,0,0,0,338,1893,1,0,0,0,340,1906,1,0,0,0,342,1911,
        1,0,0,0,344,1916,1,0,0,0,346,1924,1,0,0,0,348,1929,1,0,0,0,350,1958,
        1,0,0,0,352,1987,1,0,0,0,354,1989,1,0,0,0,356,1997,1,0,0,0,358,2005,
        1,0,0,0,360,2007,1,0,0,0,362,2018,1,0,0,0,364,2029,1,0,0,0,366,2045,
        1,0,0,0,368,2057,1,0,0,0,370,2074,1,0,0,0,372,2082,1,0,0,0,374,2084,
        1,0,0,0,376,2093,1,0,0,0,378,2116,1,0,0,0,380,2137,1,0,0,0,382,2154,
        1,0,0,0,384,2187,1,0,0,0,386,2192,1,0,0,0,388,2194,1,0,0,0,390,2198,
        1,0,0,0,392,394,3,8,4,0,393,392,1,0,0,0,393,394,1,0,0,0,394,395,
        1,0,0,0,395,396,5,0,0,1,396,1,1,0,0,0,397,398,3,12,6,0,398,3,1,0,
        0,0,399,403,3,208,104,0,400,402,5,98,0,0,401,400,1,0,0,0,402,405,
        1,0,0,0,403,401,1,0,0,0,403,404,1,0,0,0,404,406,1,0,0,0,405,403,
        1,0,0,0,406,407,5,0,0,1,407,5,1,0,0,0,408,410,5,8,0,0,409,411,3,
        384,192,0,410,409,1,0,0,0,410,411,1,0,0,0,411,412,1,0,0,0,412,413,
        5,11,0,0,413,414,5,52,0,0,414,418,3,210,105,0,415,417,5,98,0,0,416,
        415,1,0,0,0,417,420,1,0,0,0,418,416,1,0,0,0,418,419,1,0,0,0,419,
        421,1,0,0,0,420,418,1,0,0,0,421,422,5,0,0,1,422,7,1,0,0,0,423,425,
        3,10,5,0,424,423,1,0,0,0,425,426,1,0,0,0,426,424,1,0,0,0,426,427,
        1,0,0,0,427,9,1,0,0,0,428,431,3,18,9,0,429,431,3,14,7,0,430,428,
        1,0,0,0,430,429,1,0,0,0,431,11,1,0,0,0,432,433,3,18,9,0,433,434,
        5,98,0,0,434,439,1,0,0,0,435,439,3,14,7,0,436,439,5,98,0,0,437,439,
        5,0,0,1,438,432,1,0,0,0,438,435,1,0,0,0,438,436,1,0,0,0,438,437,
        1,0,0,0,439,13,1,0,0,0,440,445,3,16,8,0,441,442,5,17,0,0,442,444,
        3,16,8,0,443,441,1,0,0,0,444,447,1,0,0,0,445,443,1,0,0,0,445,446,
        1,0,0,0,446,449,1,0,0,0,447,445,1,0,0,0,448,450,5,17,0,0,449,448,
        1,0,0,0,449,450,1,0,0,0,450,451,1,0,0,0,451,452,5,98,0,0,452,15,
        1,0,0,0,453,468,3,20,10,0,454,468,3,194,97,0,455,468,3,214,107,0,
        456,468,3,26,13,0,457,468,3,40,20,0,458,468,3,28,14,0,459,468,5,
        60,0,0,460,468,3,34,17,0,461,468,3,36,18,0,462,468,3,38,19,0,463,
        468,5,62,0,0,464,468,5,72,0,0,465,468,3,30,15,0,466,468,3,32,16,
        0,467,453,1,0,0,0,467,454,1,0,0,0,467,455,1,0,0,0,467,456,1,0,0,
        0,467,457,1,0,0,0,467,458,1,0,0,0,467,459,1,0,0,0,467,460,1,0,0,
        0,467,461,1,0,0,0,467,462,1,0,0,0,467,463,1,0,0,0,467,464,1,0,0,
        0,467,465,1,0,0,0,467,466,1,0,0,0,468,17,1,0,0,0,469,478,3,66,33,
        0,470,478,3,100,50,0,471,478,3,62,31,0,472,478,3,110,55,0,473,478,
        3,108,54,0,474,478,3,114,57,0,475,478,3,106,53,0,476,478,3,122,61,
        0,477,469,1,0,0,0,477,470,1,0,0,0,477,471,1,0,0,0,477,472,1,0,0,
        0,477,473,1,0,0,0,477,474,1,0,0,0,477,475,1,0,0,0,477,476,1,0,0,
        0,478,19,1,0,0,0,479,480,3,390,195,0,480,481,5,15,0,0,481,484,3,
        210,105,0,482,483,5,26,0,0,483,485,3,22,11,0,484,482,1,0,0,0,484,
        485,1,0,0,0,485,520,1,0,0,0,486,487,5,8,0,0,487,488,3,372,186,0,
        488,489,5,11,0,0,489,492,1,0,0,0,490,492,3,374,187,0,491,486,1,0,
        0,0,491,490,1,0,0,0,492,493,1,0,0,0,493,494,5,15,0,0,494,497,3,210,
        105,0,495,496,5,26,0,0,496,498,3,22,11,0,497,495,1,0,0,0,497,498,
        1,0,0,0,498,520,1,0,0,0,499,500,3,360,180,0,500,501,5,26,0,0,501,
        503,1,0,0,0,502,499,1,0,0,0,503,504,1,0,0,0,504,502,1,0,0,0,504,
        505,1,0,0,0,505,508,1,0,0,0,506,509,3,212,106,0,507,509,3,214,107,
        0,508,506,1,0,0,0,508,507,1,0,0,0,509,511,1,0,0,0,510,512,5,4,0,
        0,511,510,1,0,0,0,511,512,1,0,0,0,512,520,1,0,0,0,513,514,3,372,
        186,0,514,517,3,24,12,0,515,518,3,212,106,0,516,518,3,214,107,0,
        517,515,1,0,0,0,517,516,1,0,0,0,518,520,1,0,0,0,519,479,1,0,0,0,
        519,491,1,0,0,0,519,502,1,0,0,0,519,513,1,0,0,0,520,21,1,0,0,0,521,
        524,3,212,106,0,522,524,3,214,107,0,523,521,1,0,0,0,523,522,1,0,
        0,0,524,23,1,0,0,0,525,526,7,0,0,0,526,25,1,0,0,0,527,529,5,70,0,
        0,528,530,3,214,107,0,529,528,1,0,0,0,529,530,1,0,0,0,530,27,1,0,
        0,0,531,537,5,65,0,0,532,535,3,210,105,0,533,534,5,78,0,0,534,536,
        3,210,105,0,535,533,1,0,0,0,535,536,1,0,0,0,536,538,1,0,0,0,537,
        532,1,0,0,0,537,538,1,0,0,0,538,29,1,0,0,0,539,540,5,83,0,0,540,
        545,3,390,195,0,541,542,5,16,0,0,542,544,3,390,195,0,543,541,1,0,
        0,0,544,547,1,0,0,0,545,543,1,0,0,0,545,546,1,0,0,0,546,31,1,0,0,
        0,547,545,1,0,0,0,548,549,5,79,0,0,549,554,3,390,195,0,550,551,5,
        16,0,0,551,553,3,390,195,0,552,550,1,0,0,0,553,556,1,0,0,0,554,552,
        1,0,0,0,554,555,1,0,0,0,555,33,1,0,0,0,556,554,1,0,0,0,557,558,5,
        82,0,0,558,559,3,378,189,0,559,35,1,0,0,0,560,561,3,212,106,0,561,
        37,1,0,0,0,562,563,5,81,0,0,563,566,3,210,105,0,564,565,5,16,0,0,
        565,567,3,210,105,0,566,564,1,0,0,0,566,567,1,0,0,0,567,39,1,0,0,
        0,568,571,3,42,21,0,569,571,3,44,22,0,570,568,1,0,0,0,570,569,1,
        0,0,0,571,41,1,0,0,0,572,573,5,59,0,0,573,574,3,52,26,0,574,43,1,
        0,0,0,575,579,5,78,0,0,576,578,7,1,0,0,577,576,1,0,0,0,578,581,1,
        0,0,0,579,577,1,0,0,0,579,580,1,0,0,0,580,582,1,0,0,0,581,579,1,
        0,0,0,582,583,3,56,28,0,583,584,5,59,0,0,584,585,3,46,23,0,585,595,
        1,0,0,0,586,588,5,78,0,0,587,589,7,1,0,0,588,587,1,0,0,0,589,590,
        1,0,0,0,590,588,1,0,0,0,590,591,1,0,0,0,591,592,1,0,0,0,592,593,
        5,59,0,0,593,595,3,46,23,0,594,575,1,0,0,0,594,586,1,0,0,0,595,45,
        1,0,0,0,596,597,5,8,0,0,597,599,3,48,24,0,598,600,5,16,0,0,599,598,
        1,0,0,0,599,600,1,0,0,0,600,601,1,0,0,0,601,602,5,11,0,0,602,606,
        1,0,0,0,603,606,3,48,24,0,604,606,5,20,0,0,605,596,1,0,0,0,605,603,
        1,0,0,0,605,604,1,0,0,0,606,47,1,0,0,0,607,612,3,50,25,0,608,609,
        5,16,0,0,609,611,3,50,25,0,610,608,1,0,0,0,611,614,1,0,0,0,612,610,
        1,0,0,0,612,613,1,0,0,0,613,49,1,0,0,0,614,612,1,0,0,0,615,618,3,
        390,195,0,616,617,5,76,0,0,617,619,3,390,195,0,618,616,1,0,0,0,618,
        619,1,0,0,0,619,51,1,0,0,0,620,625,3,54,27,0,621,622,5,16,0,0,622,
        624,3,54,27,0,623,621,1,0,0,0,624,627,1,0,0,0,625,623,1,0,0,0,625,
        626,1,0,0,0,626,53,1,0,0,0,627,625,1,0,0,0,628,631,3,56,28,0,629,
        630,5,76,0,0,630,632,3,390,195,0,631,629,1,0,0,0,631,632,1,0,0,0,
        632,55,1,0,0,0,633,634,6,28,-1,0,634,635,3,390,195,0,635,641,1,0,
        0,0,636,637,10,2,0,0,637,638,5,14,0,0,638,640,3,390,195,0,639,636,
        1,0,0,0,640,643,1,0,0,0,641,639,1,0,0,0,641,642,1,0,0,0,642,57,1,
        0,0,0,643,641,1,0,0,0,644,645,5,98,0,0,645,646,5,2,0,0,646,647,3,
        8,4,0,647,648,5,3,0,0,648,651,1,0,0,0,649,651,3,14,7,0,650,644,1,
        0,0,0,650,649,1,0,0,0,651,59,1,0,0,0,652,653,5,50,0,0,653,654,3,
        224,112,0,654,655,5,98,0,0,655,657,1,0,0,0,656,652,1,0,0,0,657,658,
        1,0,0,0,658,656,1,0,0,0,658,659,1,0,0,0,659,61,1,0,0,0,660,661,3,
        60,30,0,661,662,3,64,32,0,662,665,1,0,0,0,663,665,3,64,32,0,664,
        660,1,0,0,0,664,663,1,0,0,0,665,63,1,0,0,0,666,667,5,67,0,0,667,
        669,3,390,195,0,668,670,3,196,98,0,669,668,1,0,0,0,669,670,1,0,0,
        0,670,676,1,0,0,0,671,673,5,8,0,0,672,674,3,348,174,0,673,672,1,
        0,0,0,673,674,1,0,0,0,674,675,1,0,0,0,675,677,5,11,0,0,676,671,1,
        0,0,0,676,677,1,0,0,0,677,678,1,0,0,0,678,679,5,15,0,0,679,680,3,
        58,29,0,680,65,1,0,0,0,681,682,3,60,30,0,682,683,3,68,34,0,683,686,
        1,0,0,0,684,686,3,68,34,0,685,681,1,0,0,0,685,684,1,0,0,0,686,67,
        1,0,0,0,687,688,5,77,0,0,688,690,3,390,195,0,689,691,3,196,98,0,
        690,689,1,0,0,0,690,691,1,0,0,0,691,692,1,0,0,0,692,694,5,8,0,0,
        693,695,3,70,35,0,694,693,1,0,0,0,694,695,1,0,0,0,695,696,1,0,0,
        0,696,699,5,11,0,0,697,698,5,52,0,0,698,700,3,210,105,0,699,697,
        1,0,0,0,699,700,1,0,0,0,700,701,1,0,0,0,701,703,5,15,0,0,702,704,
        3,386,193,0,703,702,1,0,0,0,703,704,1,0,0,0,704,705,1,0,0,0,705,
        706,3,58,29,0,706,729,1,0,0,0,707,708,5,86,0,0,708,709,5,77,0,0,
        709,711,3,390,195,0,710,712,3,196,98,0,711,710,1,0,0,0,711,712,1,
        0,0,0,712,713,1,0,0,0,713,715,5,8,0,0,714,716,3,70,35,0,715,714,
        1,0,0,0,715,716,1,0,0,0,716,717,1,0,0,0,717,720,5,11,0,0,718,719,
        5,52,0,0,719,721,3,210,105,0,720,718,1,0,0,0,720,721,1,0,0,0,721,
        722,1,0,0,0,722,724,5,15,0,0,723,725,3,386,193,0,724,723,1,0,0,0,
        724,725,1,0,0,0,725,726,1,0,0,0,726,727,3,58,29,0,727,729,1,0,0,
        0,728,687,1,0,0,0,728,707,1,0,0,0,729,69,1,0,0,0,730,731,3,72,36,
        0,731,71,1,0,0,0,732,736,3,74,37,0,733,735,3,82,41,0,734,733,1,0,
        0,0,735,738,1,0,0,0,736,734,1,0,0,0,736,737,1,0,0,0,737,742,1,0,
        0,0,738,736,1,0,0,0,739,741,3,86,43,0,740,739,1,0,0,0,741,744,1,
        0,0,0,742,740,1,0,0,0,742,743,1,0,0,0,743,746,1,0,0,0,744,742,1,
        0,0,0,745,747,3,78,39,0,746,745,1,0,0,0,746,747,1,0,0,0,747,782,
        1,0,0,0,748,752,3,76,38,0,749,751,3,86,43,0,750,749,1,0,0,0,751,
        754,1,0,0,0,752,750,1,0,0,0,752,753,1,0,0,0,753,756,1,0,0,0,754,
        752,1,0,0,0,755,757,3,78,39,0,756,755,1,0,0,0,756,757,1,0,0,0,757,
        782,1,0,0,0,758,760,3,82,41,0,759,758,1,0,0,0,760,761,1,0,0,0,761,
        759,1,0,0,0,761,762,1,0,0,0,762,766,1,0,0,0,763,765,3,86,43,0,764,
        763,1,0,0,0,765,768,1,0,0,0,766,764,1,0,0,0,766,767,1,0,0,0,767,
        770,1,0,0,0,768,766,1,0,0,0,769,771,3,78,39,0,770,769,1,0,0,0,770,
        771,1,0,0,0,771,782,1,0,0,0,772,774,3,86,43,0,773,772,1,0,0,0,774,
        775,1,0,0,0,775,773,1,0,0,0,775,776,1,0,0,0,776,778,1,0,0,0,777,
        779,3,78,39,0,778,777,1,0,0,0,778,779,1,0,0,0,779,782,1,0,0,0,780,
        782,3,78,39,0,781,732,1,0,0,0,781,748,1,0,0,0,781,759,1,0,0,0,781,
        773,1,0,0,0,781,780,1,0,0,0,782,73,1,0,0,0,783,785,3,82,41,0,784,
        783,1,0,0,0,785,786,1,0,0,0,786,784,1,0,0,0,786,787,1,0,0,0,787,
        788,1,0,0,0,788,790,5,21,0,0,789,791,5,16,0,0,790,789,1,0,0,0,790,
        791,1,0,0,0,791,75,1,0,0,0,792,794,3,82,41,0,793,792,1,0,0,0,794,
        797,1,0,0,0,795,793,1,0,0,0,795,796,1,0,0,0,796,799,1,0,0,0,797,
        795,1,0,0,0,798,800,3,86,43,0,799,798,1,0,0,0,800,801,1,0,0,0,801,
        799,1,0,0,0,801,802,1,0,0,0,802,803,1,0,0,0,803,805,5,21,0,0,804,
        806,5,16,0,0,805,804,1,0,0,0,805,806,1,0,0,0,806,77,1,0,0,0,807,
        808,5,20,0,0,808,812,3,82,41,0,809,811,3,88,44,0,810,809,1,0,0,0,
        811,814,1,0,0,0,812,810,1,0,0,0,812,813,1,0,0,0,813,816,1,0,0,0,
        814,812,1,0,0,0,815,817,3,80,40,0,816,815,1,0,0,0,816,817,1,0,0,
        0,817,841,1,0,0,0,818,819,5,20,0,0,819,823,3,84,42,0,820,822,3,88,
        44,0,821,820,1,0,0,0,822,825,1,0,0,0,823,821,1,0,0,0,823,824,1,0,
        0,0,824,827,1,0,0,0,825,823,1,0,0,0,826,828,3,80,40,0,827,826,1,
        0,0,0,827,828,1,0,0,0,828,841,1,0,0,0,829,830,5,20,0,0,830,832,5,
        16,0,0,831,833,3,88,44,0,832,831,1,0,0,0,833,834,1,0,0,0,834,832,
        1,0,0,0,834,835,1,0,0,0,835,837,1,0,0,0,836,838,3,80,40,0,837,836,
        1,0,0,0,837,838,1,0,0,0,838,841,1,0,0,0,839,841,3,80,40,0,840,807,
        1,0,0,0,840,818,1,0,0,0,840,829,1,0,0,0,840,839,1,0,0,0,841,79,1,
        0,0,0,842,843,5,36,0,0,843,844,3,82,41,0,844,81,1,0,0,0,845,847,
        3,90,45,0,846,848,5,16,0,0,847,846,1,0,0,0,847,848,1,0,0,0,848,850,
        1,0,0,0,849,851,5,4,0,0,850,849,1,0,0,0,850,851,1,0,0,0,851,83,1,
        0,0,0,852,854,3,92,46,0,853,855,5,16,0,0,854,853,1,0,0,0,854,855,
        1,0,0,0,855,857,1,0,0,0,856,858,5,4,0,0,857,856,1,0,0,0,857,858,
        1,0,0,0,858,85,1,0,0,0,859,860,3,90,45,0,860,862,3,98,49,0,861,863,
        5,16,0,0,862,861,1,0,0,0,862,863,1,0,0,0,863,865,1,0,0,0,864,866,
        5,4,0,0,865,864,1,0,0,0,865,866,1,0,0,0,866,87,1,0,0,0,867,869,3,
        90,45,0,868,870,3,98,49,0,869,868,1,0,0,0,869,870,1,0,0,0,870,872,
        1,0,0,0,871,873,5,16,0,0,872,871,1,0,0,0,872,873,1,0,0,0,873,875,
        1,0,0,0,874,876,5,4,0,0,875,874,1,0,0,0,875,876,1,0,0,0,876,89,1,
        0,0,0,877,879,3,390,195,0,878,880,3,94,47,0,879,878,1,0,0,0,879,
        880,1,0,0,0,880,91,1,0,0,0,881,882,3,390,195,0,882,883,3,96,48,0,
        883,93,1,0,0,0,884,885,5,15,0,0,885,886,3,210,105,0,886,95,1,0,0,
        0,887,888,5,15,0,0,888,889,3,216,108,0,889,97,1,0,0,0,890,891,5,
        26,0,0,891,892,3,210,105,0,892,99,1,0,0,0,893,894,5,88,0,0,894,895,
        3,224,112,0,895,896,5,15,0,0,896,901,3,58,29,0,897,902,3,102,51,
        0,898,900,3,104,52,0,899,898,1,0,0,0,899,900,1,0,0,0,900,902,1,0,
        0,0,901,897,1,0,0,0,901,899,1,0,0,0,902,101,1,0,0,0,903,904,5,87,
        0,0,904,905,3,224,112,0,905,906,5,15,0,0,906,911,3,58,29,0,907,912,
        3,102,51,0,908,910,3,104,52,0,909,908,1,0,0,0,909,910,1,0,0,0,910,
        912,1,0,0,0,911,907,1,0,0,0,911,909,1,0,0,0,912,103,1,0,0,0,913,
        914,5,58,0,0,914,915,5,15,0,0,915,916,3,58,29,0,916,105,1,0,0,0,
        917,918,5,80,0,0,918,919,3,224,112,0,919,920,5,15,0,0,920,922,3,
        58,29,0,921,923,3,104,52,0,922,921,1,0,0,0,922,923,1,0,0,0,923,107,
        1,0,0,0,924,926,5,86,0,0,925,924,1,0,0,0,925,926,1,0,0,0,926,927,
        1,0,0,0,927,928,5,73,0,0,928,929,3,360,180,0,929,930,5,64,0,0,930,
        931,3,214,107,0,931,933,5,15,0,0,932,934,5,4,0,0,933,932,1,0,0,0,
        933,934,1,0,0,0,934,935,1,0,0,0,935,937,3,58,29,0,936,938,3,104,
        52,0,937,936,1,0,0,0,937,938,1,0,0,0,938,109,1,0,0,0,939,940,5,85,
        0,0,940,941,5,8,0,0,941,946,3,112,56,0,942,943,5,16,0,0,943,945,
        3,112,56,0,944,942,1,0,0,0,945,948,1,0,0,0,946,944,1,0,0,0,946,947,
        1,0,0,0,947,950,1,0,0,0,948,946,1,0,0,0,949,951,5,16,0,0,950,949,
        1,0,0,0,950,951,1,0,0,0,951,952,1,0,0,0,952,953,5,11,0,0,953,955,
        5,15,0,0,954,956,5,4,0,0,955,954,1,0,0,0,955,956,1,0,0,0,956,957,
        1,0,0,0,957,958,3,58,29,0,958,996,1,0,0,0,959,960,5,86,0,0,960,961,
        5,85,0,0,961,962,5,8,0,0,962,967,3,112,56,0,963,964,5,16,0,0,964,
        966,3,112,56,0,965,963,1,0,0,0,966,969,1,0,0,0,967,965,1,0,0,0,967,
        968,1,0,0,0,968,971,1,0,0,0,969,967,1,0,0,0,970,972,5,16,0,0,971,
        970,1,0,0,0,971,972,1,0,0,0,972,973,1,0,0,0,973,974,5,11,0,0,974,
        975,5,15,0,0,975,976,3,58,29,0,976,996,1,0,0,0,977,979,5,86,0,0,
        978,977,1,0,0,0,978,979,1,0,0,0,979,980,1,0,0,0,980,981,5,85,0,0,
        981,986,3,112,56,0,982,983,5,16,0,0,983,985,3,112,56,0,984,982,1,
        0,0,0,985,988,1,0,0,0,986,984,1,0,0,0,986,987,1,0,0,0,987,989,1,
        0,0,0,988,986,1,0,0,0,989,991,5,15,0,0,990,992,5,4,0,0,991,990,1,
        0,0,0,991,992,1,0,0,0,992,993,1,0,0,0,993,994,3,58,29,0,994,996,
        1,0,0,0,995,939,1,0,0,0,995,959,1,0,0,0,995,978,1,0,0,0,996,111,
        1,0,0,0,997,1000,3,210,105,0,998,999,5,76,0,0,999,1001,3,366,183,
        0,1000,998,1,0,0,0,1000,1001,1,0,0,0,1001,113,1,0,0,0,1002,1003,
        5,75,0,0,1003,1004,5,15,0,0,1004,1005,3,58,29,0,1005,1006,3,120,
        60,0,1006,1036,1,0,0,0,1007,1008,5,75,0,0,1008,1009,5,15,0,0,1009,
        1011,3,58,29,0,1010,1012,3,116,58,0,1011,1010,1,0,0,0,1012,1013,
        1,0,0,0,1013,1011,1,0,0,0,1013,1014,1,0,0,0,1014,1016,1,0,0,0,1015,
        1017,3,104,52,0,1016,1015,1,0,0,0,1016,1017,1,0,0,0,1017,1019,1,
        0,0,0,1018,1020,3,120,60,0,1019,1018,1,0,0,0,1019,1020,1,0,0,0,1020,
        1036,1,0,0,0,1021,1022,5,75,0,0,1022,1023,5,15,0,0,1023,1025,3,58,
        29,0,1024,1026,3,118,59,0,1025,1024,1,0,0,0,1026,1027,1,0,0,0,1027,
        1025,1,0,0,0,1027,1028,1,0,0,0,1028,1030,1,0,0,0,1029,1031,3,104,
        52,0,1030,1029,1,0,0,0,1030,1031,1,0,0,0,1031,1033,1,0,0,0,1032,
        1034,3,120,60,0,1033,1032,1,0,0,0,1033,1034,1,0,0,0,1034,1036,1,
        0,0,0,1035,1002,1,0,0,0,1035,1007,1,0,0,0,1035,1021,1,0,0,0,1036,
        115,1,0,0,0,1037,1043,5,63,0,0,1038,1041,3,210,105,0,1039,1040,5,
        76,0,0,1040,1042,3,390,195,0,1041,1039,1,0,0,0,1041,1042,1,0,0,0,
        1042,1044,1,0,0,0,1043,1038,1,0,0,0,1043,1044,1,0,0,0,1044,1045,
        1,0,0,0,1045,1046,5,15,0,0,1046,1047,3,58,29,0,1047,117,1,0,0,0,
        1048,1049,5,63,0,0,1049,1050,5,20,0,0,1050,1053,3,210,105,0,1051,
        1052,5,76,0,0,1052,1054,3,390,195,0,1053,1051,1,0,0,0,1053,1054,
        1,0,0,0,1054,1055,1,0,0,0,1055,1056,5,15,0,0,1056,1057,3,58,29,0,
        1057,119,1,0,0,0,1058,1059,5,68,0,0,1059,1060,5,15,0,0,1060,1061,
        3,58,29,0,1061,121,1,0,0,0,1062,1063,5,92,0,0,1063,1064,3,124,62,
        0,1064,1065,5,15,0,0,1065,1066,5,98,0,0,1066,1068,5,2,0,0,1067,1069,
        3,126,63,0,1068,1067,1,0,0,0,1069,1070,1,0,0,0,1070,1068,1,0,0,0,
        1070,1071,1,0,0,0,1071,1072,1,0,0,0,1072,1073,5,3,0,0,1073,123,1,
        0,0,0,1074,1075,3,220,110,0,1075,1077,5,16,0,0,1076,1078,3,218,109,
        0,1077,1076,1,0,0,0,1077,1078,1,0,0,0,1078,1081,1,0,0,0,1079,1081,
        3,224,112,0,1080,1074,1,0,0,0,1080,1079,1,0,0,0,1081,125,1,0,0,0,
        1082,1083,5,93,0,0,1083,1085,3,130,65,0,1084,1086,3,128,64,0,1085,
        1084,1,0,0,0,1085,1086,1,0,0,0,1086,1087,1,0,0,0,1087,1088,5,15,
        0,0,1088,1089,3,58,29,0,1089,127,1,0,0,0,1090,1091,5,88,0,0,1091,
        1092,3,224,112,0,1092,129,1,0,0,0,1093,1096,3,170,85,0,1094,1096,
        3,132,66,0,1095,1093,1,0,0,0,1095,1094,1,0,0,0,1096,131,1,0,0,0,
        1097,1100,3,134,67,0,1098,1100,3,136,68,0,1099,1097,1,0,0,0,1099,
        1098,1,0,0,0,1100,133,1,0,0,0,1101,1102,3,136,68,0,1102,1103,5,76,
        0,0,1103,1104,3,156,78,0,1104,135,1,0,0,0,1105,1110,3,138,69,0,1106,
        1107,5,22,0,0,1107,1109,3,138,69,0,1108,1106,1,0,0,0,1109,1112,1,
        0,0,0,1110,1108,1,0,0,0,1110,1111,1,0,0,0,1111,137,1,0,0,0,1112,
        1110,1,0,0,0,1113,1122,3,140,70,0,1114,1122,3,154,77,0,1115,1122,
        3,158,79,0,1116,1122,3,160,80,0,1117,1122,3,166,83,0,1118,1122,3,
        168,84,0,1119,1122,3,178,89,0,1120,1122,3,186,93,0,1121,1113,1,0,
        0,0,1121,1114,1,0,0,0,1121,1115,1,0,0,0,1121,1116,1,0,0,0,1121,1117,
        1,0,0,0,1121,1118,1,0,0,0,1121,1119,1,0,0,0,1121,1120,1,0,0,0,1122,
        139,1,0,0,0,1123,1130,3,146,73,0,1124,1130,3,144,72,0,1125,1130,
        3,320,160,0,1126,1130,5,61,0,0,1127,1130,5,66,0,0,1128,1130,5,56,
        0,0,1129,1123,1,0,0,0,1129,1124,1,0,0,0,1129,1125,1,0,0,0,1129,1126,
        1,0,0,0,1129,1127,1,0,0,0,1129,1128,1,0,0,0,1130,141,1,0,0,0,1131,
        1138,3,146,73,0,1132,1138,3,144,72,0,1133,1138,3,320,160,0,1134,
        1138,5,61,0,0,1135,1138,5,66,0,0,1136,1138,5,56,0,0,1137,1131,1,
        0,0,0,1137,1132,1,0,0,0,1137,1133,1,0,0,0,1137,1134,1,0,0,0,1137,
        1135,1,0,0,0,1137,1136,1,0,0,0,1138,143,1,0,0,0,1139,1140,3,148,
        74,0,1140,1141,7,2,0,0,1141,1142,3,152,76,0,1142,145,1,0,0,0,1143,
        1145,5,19,0,0,1144,1143,1,0,0,0,1144,1145,1,0,0,0,1145,1146,1,0,
        0,0,1146,1147,5,96,0,0,1147,147,1,0,0,0,1148,1150,5,19,0,0,1149,
        1148,1,0,0,0,1149,1150,1,0,0,0,1150,1151,1,0,0,0,1151,1152,3,150,
        75,0,1152,149,1,0,0,0,1153,1154,5,96,0,0,1154,151,1,0,0,0,1155,1156,
        5,96,0,0,1156,153,1,0,0,0,1157,1158,3,156,78,0,1158,155,1,0,0,0,
        1159,1160,3,388,194,0,1160,157,1,0,0,0,1161,1162,5,94,0,0,1162,159,
        1,0,0,0,1163,1164,3,162,81,0,1164,161,1,0,0,0,1165,1168,3,390,195,
        0,1166,1167,5,14,0,0,1167,1169,3,390,195,0,1168,1166,1,0,0,0,1169,
        1170,1,0,0,0,1170,1168,1,0,0,0,1170,1171,1,0,0,0,1171,163,1,0,0,
        0,1172,1177,3,390,195,0,1173,1174,5,14,0,0,1174,1176,3,390,195,0,
        1175,1173,1,0,0,0,1176,1179,1,0,0,0,1177,1175,1,0,0,0,1177,1178,
        1,0,0,0,1178,165,1,0,0,0,1179,1177,1,0,0,0,1180,1181,5,8,0,0,1181,
        1182,3,132,66,0,1182,1183,5,11,0,0,1183,167,1,0,0,0,1184,1186,5,
        9,0,0,1185,1187,3,172,86,0,1186,1185,1,0,0,0,1186,1187,1,0,0,0,1187,
        1188,1,0,0,0,1188,1195,5,12,0,0,1189,1191,5,8,0,0,1190,1192,3,170,
        85,0,1191,1190,1,0,0,0,1191,1192,1,0,0,0,1192,1193,1,0,0,0,1193,
        1195,5,11,0,0,1194,1184,1,0,0,0,1194,1189,1,0,0,0,1195,169,1,0,0,
        0,1196,1197,3,174,87,0,1197,1199,5,16,0,0,1198,1200,3,172,86,0,1199,
        1198,1,0,0,0,1199,1200,1,0,0,0,1200,171,1,0,0,0,1201,1206,3,174,
        87,0,1202,1203,5,16,0,0,1203,1205,3,174,87,0,1204,1202,1,0,0,0,1205,
        1208,1,0,0,0,1206,1204,1,0,0,0,1206,1207,1,0,0,0,1207,1210,1,0,0,
        0,1208,1206,1,0,0,0,1209,1211,5,16,0,0,1210,1209,1,0,0,0,1210,1211,
        1,0,0,0,1211,173,1,0,0,0,1212,1215,3,176,88,0,1213,1215,3,132,66,
        0,1214,1212,1,0,0,0,1214,1213,1,0,0,0,1215,175,1,0,0,0,1216,1217,
        5,20,0,0,1217,1218,3,390,195,0,1218,177,1,0,0,0,1219,1220,5,10,0,
        0,1220,1240,5,13,0,0,1221,1222,5,10,0,0,1222,1224,3,184,92,0,1223,
        1225,5,16,0,0,1224,1223,1,0,0,0,1224,1225,1,0,0,0,1225,1226,1,0,
        0,0,1226,1227,5,13,0,0,1227,1240,1,0,0,0,1228,1229,5,10,0,0,1229,
        1232,3,180,90,0,1230,1231,5,16,0,0,1231,1233,3,184,92,0,1232,1230,
        1,0,0,0,1232,1233,1,0,0,0,1233,1235,1,0,0,0,1234,1236,5,16,0,0,1235,
        1234,1,0,0,0,1235,1236,1,0,0,0,1236,1237,1,0,0,0,1237,1238,5,13,
        0,0,1238,1240,1,0,0,0,1239,1219,1,0,0,0,1239,1221,1,0,0,0,1239,1228,
        1,0,0,0,1240,179,1,0,0,0,1241,1246,3,182,91,0,1242,1243,5,16,0,0,
        1243,1245,3,182,91,0,1244,1242,1,0,0,0,1245,1248,1,0,0,0,1246,1244,
        1,0,0,0,1246,1247,1,0,0,0,1247,181,1,0,0,0,1248,1246,1,0,0,0,1249,
        1252,3,142,71,0,1250,1252,3,162,81,0,1251,1249,1,0,0,0,1251,1250,
        1,0,0,0,1252,1253,1,0,0,0,1253,1254,5,15,0,0,1254,1255,3,132,66,
        0,1255,183,1,0,0,0,1256,1257,5,36,0,0,1257,1258,3,156,78,0,1258,
        185,1,0,0,0,1259,1260,3,164,82,0,1260,1272,5,8,0,0,1261,1264,3,188,
        94,0,1262,1263,5,16,0,0,1263,1265,3,190,95,0,1264,1262,1,0,0,0,1264,
        1265,1,0,0,0,1265,1268,1,0,0,0,1266,1268,3,190,95,0,1267,1261,1,
        0,0,0,1267,1266,1,0,0,0,1268,1270,1,0,0,0,1269,1271,5,16,0,0,1270,
        1269,1,0,0,0,1270,1271,1,0,0,0,1271,1273,1,0,0,0,1272,1267,1,0,0,
        0,1272,1273,1,0,0,0,1273,1274,1,0,0,0,1274,1275,5,11,0,0,1275,187,
        1,0,0,0,1276,1281,3,132,66,0,1277,1278,5,16,0,0,1278,1280,3,132,
        66,0,1279,1277,1,0,0,0,1280,1283,1,0,0,0,1281,1279,1,0,0,0,1281,
        1282,1,0,0,0,1282,189,1,0,0,0,1283,1281,1,0,0,0,1284,1289,3,192,
        96,0,1285,1286,5,16,0,0,1286,1288,3,192,96,0,1287,1285,1,0,0,0,1288,
        1291,1,0,0,0,1289,1287,1,0,0,0,1289,1290,1,0,0,0,1290,191,1,0,0,
        0,1291,1289,1,0,0,0,1292,1293,3,390,195,0,1293,1294,5,26,0,0,1294,
        1295,3,132,66,0,1295,193,1,0,0,0,1296,1297,5,91,0,0,1297,1299,3,
        390,195,0,1298,1300,3,196,98,0,1299,1298,1,0,0,0,1299,1300,1,0,0,
        0,1300,1301,1,0,0,0,1301,1302,5,26,0,0,1302,1303,3,210,105,0,1303,
        195,1,0,0,0,1304,1305,5,9,0,0,1305,1306,3,198,99,0,1306,1307,5,12,
        0,0,1307,197,1,0,0,0,1308,1313,3,200,100,0,1309,1310,5,16,0,0,1310,
        1312,3,200,100,0,1311,1309,1,0,0,0,1312,1315,1,0,0,0,1313,1311,1,
        0,0,0,1313,1314,1,0,0,0,1314,1317,1,0,0,0,1315,1313,1,0,0,0,1316,
        1318,5,16,0,0,1317,1316,1,0,0,0,1317,1318,1,0,0,0,1318,199,1,0,0,
        0,1319,1321,3,390,195,0,1320,1322,3,202,101,0,1321,1320,1,0,0,0,
        1321,1322,1,0,0,0,1322,1324,1,0,0,0,1323,1325,3,204,102,0,1324,1323,
        1,0,0,0,1324,1325,1,0,0,0,1325,1337,1,0,0,0,1326,1327,5,20,0,0,1327,
        1329,3,390,195,0,1328,1330,3,206,103,0,1329,1328,1,0,0,0,1329,1330,
        1,0,0,0,1330,1337,1,0,0,0,1331,1332,5,36,0,0,1332,1334,3,390,195,
        0,1333,1335,3,204,102,0,1334,1333,1,0,0,0,1334,1335,1,0,0,0,1335,
        1337,1,0,0,0,1336,1319,1,0,0,0,1336,1326,1,0,0,0,1336,1331,1,0,0,
        0,1337,201,1,0,0,0,1338,1339,5,15,0,0,1339,1340,3,210,105,0,1340,
        203,1,0,0,0,1341,1342,5,26,0,0,1342,1343,3,210,105,0,1343,205,1,
        0,0,0,1344,1345,5,26,0,0,1345,1346,3,216,108,0,1346,207,1,0,0,0,
        1347,1352,3,210,105,0,1348,1349,5,16,0,0,1349,1351,3,210,105,0,1350,
        1348,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,16,0,0,1356,1355,
        1,0,0,0,1356,1357,1,0,0,0,1357,209,1,0,0,0,1358,1364,3,226,113,0,
        1359,1360,5,88,0,0,1360,1361,3,226,113,0,1361,1362,5,58,0,0,1362,
        1363,3,210,105,0,1363,1365,1,0,0,0,1364,1359,1,0,0,0,1364,1365,1,
        0,0,0,1365,1368,1,0,0,0,1366,1368,3,284,142,0,1367,1358,1,0,0,0,
        1367,1366,1,0,0,0,1368,211,1,0,0,0,1369,1375,5,90,0,0,1370,1371,
        5,78,0,0,1371,1376,3,210,105,0,1372,1374,3,214,107,0,1373,1372,1,
        0,0,0,1373,1374,1,0,0,0,1374,1376,1,0,0,0,1375,1370,1,0,0,0,1375,
        1373,1,0,0,0,1376,213,1,0,0,0,1377,1382,3,216,108,0,1378,1379,5,
        16,0,0,1379,1381,3,216,108,0,1380,1378,1,0,0,0,1381,1384,1,0,0,0,
        1382,1380,1,0,0,0,1382,1383,1,0,0,0,1383,1386,1,0,0,0,1384,1382,
        1,0,0,0,1385,1387,5,16,0,0,1386,1385,1,0,0,0,1386,1387,1,0,0,0,1387,
        215,1,0,0,0,1388,1389,5,20,0,0,1389,1392,3,256,128,0,1390,1392,3,
        210,105,0,1391,1388,1,0,0,0,1391,1390,1,0,0,0,1392,217,1,0,0,0,1393,
        1398,3,220,110,0,1394,1395,5,16,0,0,1395,1397,3,220,110,0,1396,1394,
        1,0,0,0,1397,1400,1,0,0,0,1398,1396,1,0,0,0,1398,1399,1,0,0,0,1399,
        1402,1,0,0,0,1400,1398,1,0,0,0,1401,1403,5,16,0,0,1402,1401,1,0,
        0,0,1402,1403,1,0,0,0,1403,219,1,0,0,0,1404,1405,5,20,0,0,1405,1408,
        3,256,128,0,1406,1408,3,224,112,0,1407,1404,1,0,0,0,1407,1406,1,
        0,0,0,1408,221,1,0,0,0,1409,1410,3,390,195,0,1410,1411,5,54,0,0,
        1411,1412,3,210,105,0,1412,223,1,0,0,0,1413,1416,3,222,111,0,1414,
        1416,3,210,105,0,1415,1413,1,0,0,0,1415,1414,1,0,0,0,1416,225,1,
        0,0,0,1417,1422,3,228,114,0,1418,1419,5,89,0,0,1419,1421,3,228,114,
        0,1420,1418,1,0,0,0,1421,1424,1,0,0,0,1422,1420,1,0,0,0,1422,1423,
        1,0,0,0,1423,227,1,0,0,0,1424,1422,1,0,0,0,1425,1430,3,230,115,0,
        1426,1427,5,71,0,0,1427,1429,3,230,115,0,1428,1426,1,0,0,0,1429,
        1432,1,0,0,0,1430,1428,1,0,0,0,1430,1431,1,0,0,0,1431,229,1,0,0,
        0,1432,1430,1,0,0,0,1433,1434,5,84,0,0,1434,1437,3,230,115,0,1435,
        1437,3,232,116,0,1436,1433,1,0,0,0,1436,1435,1,0,0,0,1437,231,1,
        0,0,0,1438,1442,3,256,128,0,1439,1441,3,234,117,0,1440,1439,1,0,
        0,0,1441,1444,1,0,0,0,1442,1440,1,0,0,0,1442,1443,1,0,0,0,1443,233,
        1,0,0,0,1444,1442,1,0,0,0,1445,1456,3,236,118,0,1446,1456,3,238,
        119,0,1447,1456,3,240,120,0,1448,1456,3,242,121,0,1449,1456,3,244,
        122,0,1450,1456,3,246,123,0,1451,1456,3,248,124,0,1452,1456,3,250,
        125,0,1453,1456,3,252,126,0,1454,1456,3,254,127,0,1455,1445,1,0,
        0,0,1455,1446,1,0,0,0,1455,1447,1,0,0,0,1455,1448,1,0,0,0,1455,1449,
        1,0,0,0,1455,1450,1,0,0,0,1455,1451,1,0,0,0,1455,1452,1,0,0,0,1455,
        1453,1,0,0,0,1455,1454,1,0,0,0,1456,235,1,0,0,0,1457,1458,5,28,0,
        0,1458,1459,3,256,128,0,1459,237,1,0,0,0,1460,1461,5,29,0,0,1461,
        1462,3,256,128,0,1462,239,1,0,0,0,1463,1464,5,30,0,0,1464,1465,3,
        256,128,0,1465,241,1,0,0,0,1466,1467,5,24,0,0,1467,1468,3,256,128,
        0,1468,243,1,0,0,0,1469,1470,5,31,0,0,1470,1471,3,256,128,0,1471,
        245,1,0,0,0,1472,1473,5,25,0,0,1473,1474,3,256,128,0,1474,247,1,
        0,0,0,1475,1476,5,84,0,0,1476,1477,5,64,0,0,1477,1478,3,256,128,
        0,1478,249,1,0,0,0,1479,1480,5,64,0,0,1480,1481,3,256,128,0,1481,
        251,1,0,0,0,1482,1483,5,69,0,0,1483,1484,5,84,0,0,1484,1485,3,256,
        128,0,1485,253,1,0,0,0,1486,1487,5,69,0,0,1487,1488,3,256,128,0,
        1488,255,1,0,0,0,1489,1490,6,128,-1,0,1490,1491,3,258,129,0,1491,
        1497,1,0,0,0,1492,1493,10,2,0,0,1493,1494,5,22,0,0,1494,1496,3,258,
        129,0,1495,1492,1,0,0,0,1496,1499,1,0,0,0,1497,1495,1,0,0,0,1497,
        1498,1,0,0,0,1498,257,1,0,0,0,1499,1497,1,0,0,0,1500,1501,6,129,
        -1,0,1501,1502,3,260,130,0,1502,1508,1,0,0,0,1503,1504,10,2,0,0,
        1504,1505,5,33,0,0,1505,1507,3,260,130,0,1506,1503,1,0,0,0,1507,
        1510,1,0,0,0,1508,1506,1,0,0,0,1508,1509,1,0,0,0,1509,259,1,0,0,
        0,1510,1508,1,0,0,0,1511,1512,6,130,-1,0,1512,1513,3,262,131,0,1513,
        1519,1,0,0,0,1514,1515,10,2,0,0,1515,1516,5,23,0,0,1516,1518,3,262,
        131,0,1517,1514,1,0,0,0,1518,1521,1,0,0,0,1519,1517,1,0,0,0,1519,
        1520,1,0,0,0,1520,261,1,0,0,0,1521,1519,1,0,0,0,1522,1523,6,131,
        -1,0,1523,1524,3,264,132,0,1524,1530,1,0,0,0,1525,1526,10,2,0,0,
        1526,1527,7,3,0,0,1527,1529,3,264,132,0,1528,1525,1,0,0,0,1529,1532,
        1,0,0,0,1530,1528,1,0,0,0,1530,1531,1,0,0,0,1531,263,1,0,0,0,1532,
        1530,1,0,0,0,1533,1534,6,132,-1,0,1534,1535,3,266,133,0,1535,1541,
        1,0,0,0,1536,1537,10,2,0,0,1537,1538,7,2,0,0,1538,1540,3,266,133,
        0,1539,1536,1,0,0,0,1540,1543,1,0,0,0,1541,1539,1,0,0,0,1541,1542,
        1,0,0,0,1542,265,1,0,0,0,1543,1541,1,0,0,0,1544,1545,6,133,-1,0,
        1545,1546,3,268,134,0,1546,1552,1,0,0,0,1547,1548,10,2,0,0,1548,
        1549,7,4,0,0,1549,1551,3,268,134,0,1550,1547,1,0,0,0,1551,1554,1,
        0,0,0,1552,1550,1,0,0,0,1552,1553,1,0,0,0,1553,267,1,0,0,0,1554,
        1552,1,0,0,0,1555,1556,5,18,0,0,1556,1563,3,268,134,0,1557,1558,
        5,19,0,0,1558,1563,3,268,134,0,1559,1560,5,32,0,0,1560,1563,3,268,
        134,0,1561,1563,3,270,135,0,1562,1555,1,0,0,0,1562,1557,1,0,0,0,
        1562,1559,1,0,0,0,1562,1561,1,0,0,0,1563,269,1,0,0,0,1564,1567,3,
        272,136,0,1565,1566,5,36,0,0,1566,1568,3,268,134,0,1567,1565,1,0,
        0,0,1567,1568,1,0,0,0,1568,271,1,0,0,0,1569,1570,5,57,0,0,1570,1573,
        3,274,137,0,1571,1573,3,274,137,0,1572,1569,1,0,0,0,1572,1571,1,
        0,0,0,1573,273,1,0,0,0,1574,1575,6,137,-1,0,1575,1576,3,280,140,
        0,1576,1594,1,0,0,0,1577,1590,10,2,0,0,1578,1579,5,14,0,0,1579,1591,
        3,390,195,0,1580,1591,3,344,172,0,1581,1583,5,8,0,0,1582,1584,3,
        348,174,0,1583,1582,1,0,0,0,1583,1584,1,0,0,0,1584,1585,1,0,0,0,
        1585,1591,5,11,0,0,1586,1587,5,9,0,0,1587,1588,3,276,138,0,1588,
        1589,5,12,0,0,1589,1591,1,0,0,0,1590,1578,1,0,0,0,1590,1580,1,0,
        0,0,1590,1581,1,0,0,0,1590,1586,1,0,0,0,1591,1593,1,0,0,0,1592,1577,
        1,0,0,0,1593,1596,1,0,0,0,1594,1592,1,0,0,0,1594,1595,1,0,0,0,1595,
        275,1,0,0,0,1596,1594,1,0,0,0,1597,1616,3,278,139,0,1598,1601,3,
        278,139,0,1599,1601,3,354,177,0,1600,1598,1,0,0,0,1600,1599,1,0,
        0,0,1601,1609,1,0,0,0,1602,1605,5,16,0,0,1603,1606,3,278,139,0,1604,
        1606,3,354,177,0,1605,1603,1,0,0,0,1605,1604,1,0,0,0,1606,1608,1,
        0,0,0,1607,1602,1,0,0,0,1608,1611,1,0,0,0,1609,1607,1,0,0,0,1609,
        1610,1,0,0,0,1610,1613,1,0,0,0,1611,1609,1,0,0,0,1612,1614,5,16,
        0,0,1613,1612,1,0,0,0,1613,1614,1,0,0,0,1614,1616,1,0,0,0,1615,1597,
        1,0,0,0,1615,1600,1,0,0,0,1616,277,1,0,0,0,1617,1619,3,210,105,0,
        1618,1617,1,0,0,0,1618,1619,1,0,0,0,1619,1620,1,0,0,0,1620,1622,
        5,15,0,0,1621,1623,3,210,105,0,1622,1621,1,0,0,0,1622,1623,1,0,0,
        0,1623,1628,1,0,0,0,1624,1626,5,15,0,0,1625,1627,3,210,105,0,1626,
        1625,1,0,0,0,1626,1627,1,0,0,0,1627,1629,1,0,0,0,1628,1624,1,0,0,
        0,1628,1629,1,0,0,0,1629,1632,1,0,0,0,1630,1632,3,224,112,0,1631,
        1618,1,0,0,0,1631,1630,1,0,0,0,1632,279,1,0,0,0,1633,1656,3,390,
        195,0,1634,1656,5,66,0,0,1635,1656,5,56,0,0,1636,1656,5,61,0,0,1637,
        1656,3,320,160,0,1638,1656,5,96,0,0,1639,1643,3,324,162,0,1640,1643,
        3,282,141,0,1641,1643,3,344,172,0,1642,1639,1,0,0,0,1642,1640,1,
        0,0,0,1642,1641,1,0,0,0,1643,1656,1,0,0,0,1644,1647,3,322,161,0,
        1645,1647,3,340,170,0,1646,1644,1,0,0,0,1646,1645,1,0,0,0,1647,1656,
        1,0,0,0,1648,1653,3,328,164,0,1649,1653,3,326,163,0,1650,1653,3,
        346,173,0,1651,1653,3,342,171,0,1652,1648,1,0,0,0,1652,1649,1,0,
        0,0,1652,1650,1,0,0,0,1652,1651,1,0,0,0,1653,1656,1,0,0,0,1654,1656,
        5,53,0,0,1655,1633,1,0,0,0,1655,1634,1,0,0,0,1655,1635,1,0,0,0,1655,
        1636,1,0,0,0,1655,1637,1,0,0,0,1655,1638,1,0,0,0,1655,1642,1,0,0,
        0,1655,1646,1,0,0,0,1655,1652,1,0,0,0,1655,1654,1,0,0,0,1656,281,
        1,0,0,0,1657,1660,5,8,0,0,1658,1661,3,212,106,0,1659,1661,3,224,
        112,0,1660,1658,1,0,0,0,1660,1659,1,0,0,0,1661,1662,1,0,0,0,1662,
        1663,5,11,0,0,1663,283,1,0,0,0,1664,1666,5,74,0,0,1665,1667,3,286,
        143,0,1666,1665,1,0,0,0,1666,1667,1,0,0,0,1667,1668,1,0,0,0,1668,
        1669,5,15,0,0,1669,1670,3,210,105,0,1670,285,1,0,0,0,1671,1672,3,
        288,144,0,1672,287,1,0,0,0,1673,1677,3,290,145,0,1674,1676,3,298,
        149,0,1675,1674,1,0,0,0,1676,1679,1,0,0,0,1677,1675,1,0,0,0,1677,
        1678,1,0,0,0,1678,1683,1,0,0,0,1679,1677,1,0,0,0,1680,1682,3,300,
        150,0,1681,1680,1,0,0,0,1682,1685,1,0,0,0,1683,1681,1,0,0,0,1683,
        1684,1,0,0,0,1684,1687,1,0,0,0,1685,1683,1,0,0,0,1686,1688,3,294,
        147,0,1687,1686,1,0,0,0,1687,1688,1,0,0,0,1688,1723,1,0,0,0,1689,
        1693,3,292,146,0,1690,1692,3,300,150,0,1691,1690,1,0,0,0,1692,1695,
        1,0,0,0,1693,1691,1,0,0,0,1693,1694,1,0,0,0,1694,1697,1,0,0,0,1695,
        1693,1,0,0,0,1696,1698,3,294,147,0,1697,1696,1,0,0,0,1697,1698,1,
        0,0,0,1698,1723,1,0,0,0,1699,1701,3,298,149,0,1700,1699,1,0,0,0,
        1701,1702,1,0,0,0,1702,1700,1,0,0,0,1702,1703,1,0,0,0,1703,1707,
        1,0,0,0,1704,1706,3,300,150,0,1705,1704,1,0,0,0,1706,1709,1,0,0,
        0,1707,1705,1,0,0,0,1707,1708,1,0,0,0,1708,1711,1,0,0,0,1709,1707,
        1,0,0,0,1710,1712,3,294,147,0,1711,1710,1,0,0,0,1711,1712,1,0,0,
        0,1712,1723,1,0,0,0,1713,1715,3,300,150,0,1714,1713,1,0,0,0,1715,
        1716,1,0,0,0,1716,1714,1,0,0,0,1716,1717,1,0,0,0,1717,1719,1,0,0,
        0,1718,1720,3,294,147,0,1719,1718,1,0,0,0,1719,1720,1,0,0,0,1720,
        1723,1,0,0,0,1721,1723,3,294,147,0,1722,1673,1,0,0,0,1722,1689,1,
        0,0,0,1722,1700,1,0,0,0,1722,1714,1,0,0,0,1722,1721,1,0,0,0,1723,
        289,1,0,0,0,1724,1726,3,298,149,0,1725,1724,1,0,0,0,1726,1727,1,
        0,0,0,1727,1725,1,0,0,0,1727,1728,1,0,0,0,1728,1729,1,0,0,0,1729,
        1731,5,21,0,0,1730,1732,5,16,0,0,1731,1730,1,0,0,0,1731,1732,1,0,
        0,0,1732,291,1,0,0,0,1733,1735,3,298,149,0,1734,1733,1,0,0,0,1735,
        1738,1,0,0,0,1736,1734,1,0,0,0,1736,1737,1,0,0,0,1737,1740,1,0,0,
        0,1738,1736,1,0,0,0,1739,1741,3,300,150,0,1740,1739,1,0,0,0,1741,
        1742,1,0,0,0,1742,1740,1,0,0,0,1742,1743,1,0,0,0,1743,1744,1,0,0,
        0,1744,1746,5,21,0,0,1745,1747,5,16,0,0,1746,1745,1,0,0,0,1746,1747,
        1,0,0,0,1747,293,1,0,0,0,1748,1749,5,20,0,0,1749,1753,3,298,149,
        0,1750,1752,3,302,151,0,1751,1750,1,0,0,0,1752,1755,1,0,0,0,1753,
        1751,1,0,0,0,1753,1754,1,0,0,0,1754,1757,1,0,0,0,1755,1753,1,0,0,
        0,1756,1758,3,296,148,0,1757,1756,1,0,0,0,1757,1758,1,0,0,0,1758,
        1771,1,0,0,0,1759,1760,5,20,0,0,1760,1762,5,16,0,0,1761,1763,3,302,
        151,0,1762,1761,1,0,0,0,1763,1764,1,0,0,0,1764,1762,1,0,0,0,1764,
        1765,1,0,0,0,1765,1767,1,0,0,0,1766,1768,3,296,148,0,1767,1766,1,
        0,0,0,1767,1768,1,0,0,0,1768,1771,1,0,0,0,1769,1771,3,296,148,0,
        1770,1748,1,0,0,0,1770,1759,1,0,0,0,1770,1769,1,0,0,0,1771,295,1,
        0,0,0,1772,1773,5,36,0,0,1773,1774,3,298,149,0,1774,297,1,0,0,0,
        1775,1777,3,304,152,0,1776,1778,5,16,0,0,1777,1776,1,0,0,0,1777,
        1778,1,0,0,0,1778,299,1,0,0,0,1779,1780,3,304,152,0,1780,1782,3,
        98,49,0,1781,1783,5,16,0,0,1782,1781,1,0,0,0,1782,1783,1,0,0,0,1783,
        301,1,0,0,0,1784,1786,3,304,152,0,1785,1787,3,98,49,0,1786,1785,
        1,0,0,0,1786,1787,1,0,0,0,1787,1789,1,0,0,0,1788,1790,5,16,0,0,1789,
        1788,1,0,0,0,1789,1790,1,0,0,0,1790,303,1,0,0,0,1791,1792,3,390,
        195,0,1792,305,1,0,0,0,1793,1796,3,308,154,0,1794,1796,5,6,0,0,1795,
        1793,1,0,0,0,1795,1794,1,0,0,0,1796,307,1,0,0,0,1797,1798,5,10,0,
        0,1798,1800,3,22,11,0,1799,1801,5,26,0,0,1800,1799,1,0,0,0,1800,
        1801,1,0,0,0,1801,1803,1,0,0,0,1802,1804,3,310,155,0,1803,1802,1,
        0,0,0,1803,1804,1,0,0,0,1804,1806,1,0,0,0,1805,1807,3,312,156,0,
        1806,1805,1,0,0,0,1806,1807,1,0,0,0,1807,1808,1,0,0,0,1808,1809,
        5,13,0,0,1809,309,1,0,0,0,1810,1811,5,55,0,0,1811,1812,3,390,195,
        0,1812,311,1,0,0,0,1813,1817,5,15,0,0,1814,1816,3,314,157,0,1815,
        1814,1,0,0,0,1816,1819,1,0,0,0,1817,1815,1,0,0,0,1817,1818,1,0,0,
        0,1818,313,1,0,0,0,1819,1817,1,0,0,0,1820,1823,5,6,0,0,1821,1823,
        3,308,154,0,1822,1820,1,0,0,0,1822,1821,1,0,0,0,1823,315,1,0,0,0,
        1824,1828,5,5,0,0,1825,1827,3,306,153,0,1826,1825,1,0,0,0,1827,1830,
        1,0,0,0,1828,1826,1,0,0,0,1828,1829,1,0,0,0,1829,1831,1,0,0,0,1830,
        1828,1,0,0,0,1831,1832,5,7,0,0,1832,317,1,0,0,0,1833,1834,5,97,0,
        0,1834,319,1,0,0,0,1835,1838,3,316,158,0,1836,1838,3,318,159,0,1837,
        1835,1,0,0,0,1837,1836,1,0,0,0,1838,1839,1,0,0,0,1839,1837,1,0,0,
        0,1839,1840,1,0,0,0,1840,321,1,0,0,0,1841,1843,5,9,0,0,1842,1844,
        3,218,109,0,1843,1842,1,0,0,0,1843,1844,1,0,0,0,1844,1845,1,0,0,
        0,1845,1846,5,12,0,0,1846,323,1,0,0,0,1847,1853,5,8,0,0,1848,1849,
        3,220,110,0,1849,1851,5,16,0,0,1850,1852,3,218,109,0,1851,1850,1,
        0,0,0,1851,1852,1,0,0,0,1852,1854,1,0,0,0,1853,1848,1,0,0,0,1853,
        1854,1,0,0,0,1854,1855,1,0,0,0,1855,1856,5,11,0,0,1856,325,1,0,0,
        0,1857,1858,5,10,0,0,1858,1859,3,218,109,0,1859,1860,5,13,0,0,1860,
        327,1,0,0,0,1861,1863,5,10,0,0,1862,1864,3,330,165,0,1863,1862,1,
        0,0,0,1863,1864,1,0,0,0,1864,1865,1,0,0,0,1865,1866,5,13,0,0,1866,
        329,1,0,0,0,1867,1872,3,332,166,0,1868,1869,5,16,0,0,1869,1871,3,
        332,166,0,1870,1868,1,0,0,0,1871,1874,1,0,0,0,1872,1870,1,0,0,0,
        1872,1873,1,0,0,0,1873,1876,1,0,0,0,1874,1872,1,0,0,0,1875,1877,
        5,16,0,0,1876,1875,1,0,0,0,1876,1877,1,0,0,0,1877,331,1,0,0,0,1878,
        1879,5,36,0,0,1879,1882,3,256,128,0,1880,1882,3,334,167,0,1881,1878,
        1,0,0,0,1881,1880,1,0,0,0,1882,333,1,0,0,0,1883,1884,3,210,105,0,
        1884,1885,5,15,0,0,1885,1886,3,210,105,0,1886,335,1,0,0,0,1887,1889,
        3,338,169,0,1888,1887,1,0,0,0,1889,1890,1,0,0,0,1890,1888,1,0,0,
        0,1890,1891,1,0,0,0,1891,337,1,0,0,0,1892,1894,5,86,0,0,1893,1892,
        1,0,0,0,1893,1894,1,0,0,0,1894,1895,1,0,0,0,1895,1896,5,73,0,0,1896,
        1897,3,360,180,0,1897,1898,5,64,0,0,1898,1903,3,226,113,0,1899,1900,
        5,88,0,0,1900,1902,3,226,113,0,1901,1899,1,0,0,0,1902,1905,1,0,0,
        0,1903,1901,1,0,0,0,1903,1904,1,0,0,0,1904,339,1,0,0,0,1905,1903,
        1,0,0,0,1906,1907,5,9,0,0,1907,1908,3,224,112,0,1908,1909,3,336,
        168,0,1909,1910,5,12,0,0,1910,341,1,0,0,0,1911,1912,5,10,0,0,1912,
        1913,3,224,112,0,1913,1914,3,336,168,0,1914,1915,5,13,0,0,1915,343,
        1,0,0,0,1916,1919,5,8,0,0,1917,1920,3,222,111,0,1918,1920,3,210,
        105,0,1919,1917,1,0,0,0,1919,1918,1,0,0,0,1920,1921,1,0,0,0,1921,
        1922,3,336,168,0,1922,1923,5,11,0,0,1923,345,1,0,0,0,1924,1925,5,
        10,0,0,1925,1926,3,334,167,0,1926,1927,3,336,168,0,1927,1928,5,13,
        0,0,1928,347,1,0,0,0,1929,1931,3,350,175,0,1930,1932,5,16,0,0,1931,
        1930,1,0,0,0,1931,1932,1,0,0,0,1932,349,1,0,0,0,1933,1939,3,354,
        177,0,1934,1937,3,222,111,0,1935,1937,3,210,105,0,1936,1934,1,0,
        0,0,1936,1935,1,0,0,0,1937,1939,1,0,0,0,1938,1933,1,0,0,0,1938,1936,
        1,0,0,0,1939,1950,1,0,0,0,1940,1946,5,16,0,0,1941,1947,3,354,177,
        0,1942,1945,3,222,111,0,1943,1945,3,210,105,0,1944,1942,1,0,0,0,
        1944,1943,1,0,0,0,1945,1947,1,0,0,0,1946,1941,1,0,0,0,1946,1944,
        1,0,0,0,1947,1949,1,0,0,0,1948,1940,1,0,0,0,1949,1952,1,0,0,0,1950,
        1948,1,0,0,0,1950,1951,1,0,0,0,1951,1955,1,0,0,0,1952,1950,1,0,0,
        0,1953,1954,5,16,0,0,1954,1956,3,352,176,0,1955,1953,1,0,0,0,1955,
        1956,1,0,0,0,1956,1959,1,0,0,0,1957,1959,3,352,176,0,1958,1938,1,
        0,0,0,1958,1957,1,0,0,0,1959,351,1,0,0,0,1960,1965,3,356,178,0,1961,
        1962,5,16,0,0,1962,1964,3,356,178,0,1963,1961,1,0,0,0,1964,1967,
        1,0,0,0,1965,1963,1,0,0,0,1965,1966,1,0,0,0,1966,1977,1,0,0,0,1967,
        1965,1,0,0,0,1968,1969,5,16,0,0,1969,1974,3,358,179,0,1970,1971,
        5,16,0,0,1971,1973,3,358,179,0,1972,1970,1,0,0,0,1973,1976,1,0,0,
        0,1974,1972,1,0,0,0,1974,1975,1,0,0,0,1975,1978,1,0,0,0,1976,1974,
        1,0,0,0,1977,1968,1,0,0,0,1977,1978,1,0,0,0,1978,1988,1,0,0,0,1979,
        1984,3,358,179,0,1980,1981,5,16,0,0,1981,1983,3,358,179,0,1982,1980,
        1,0,0,0,1983,1986,1,0,0,0,1984,1982,1,0,0,0,1984,1985,1,0,0,0,1985,
        1988,1,0,0,0,1986,1984,1,0,0,0,1987,1960,1,0,0,0,1987,1979,1,0,0,
        0,1988,353,1,0,0,0,1989,1990,5,20,0,0,1990,1991,3,210,105,0,1991,
        355,1,0,0,0,1992,1993,3,390,195,0,1993,1994,5,26,0,0,1994,1995,3,
        210,105,0,1995,1998,1,0,0,0,1996,1998,3,354,177,0,1997,1992,1,0,
        0,0,1997,1996,1,0,0,0,1998,357,1,0,0,0,1999,2000,3,390,195,0,2000,
        2001,5,26,0,0,2001,2002,3,210,105,0,2002,2006,1,0,0,0,2003,2004,
        5,36,0,0,2004,2006,3,210,105,0,2005,1999,1,0,0,0,2005,2003,1,0,0,
        0,2006,359,1,0,0,0,2007,2012,3,366,183,0,2008,2009,5,16,0,0,2009,
        2011,3,366,183,0,2010,2008,1,0,0,0,2011,2014,1,0,0,0,2012,2010,1,
        0,0,0,2012,2013,1,0,0,0,2013,2016,1,0,0,0,2014,2012,1,0,0,0,2015,
        2017,5,16,0,0,2016,2015,1,0,0,0,2016,2017,1,0,0,0,2017,361,1,0,0,
        0,2018,2023,3,366,183,0,2019,2020,5,16,0,0,2020,2022,3,366,183,0,
        2021,2019,1,0,0,0,2022,2025,1,0,0,0,2023,2021,1,0,0,0,2023,2024,
        1,0,0,0,2024,2027,1,0,0,0,2025,2023,1,0,0,0,2026,2028,5,16,0,0,2027,
        2026,1,0,0,0,2027,2028,1,0,0,0,2028,363,1,0,0,0,2029,2040,3,366,
        183,0,2030,2041,5,16,0,0,2031,2032,5,16,0,0,2032,2034,3,366,183,
        0,2033,2031,1,0,0,0,2034,2035,1,0,0,0,2035,2033,1,0,0,0,2035,2036,
        1,0,0,0,2036,2038,1,0,0,0,2037,2039,5,16,0,0,2038,2037,1,0,0,0,2038,
        2039,1,0,0,0,2039,2041,1,0,0,0,2040,2030,1,0,0,0,2040,2033,1,0,0,
        0,2041,365,1,0,0,0,2042,2043,5,20,0,0,2043,2046,3,366,183,0,2044,
        2046,3,368,184,0,2045,2042,1,0,0,0,2045,2044,1,0,0,0,2046,367,1,
        0,0,0,2047,2054,3,376,188,0,2048,2049,5,14,0,0,2049,2055,3,390,195,
        0,2050,2051,5,9,0,0,2051,2052,3,276,138,0,2052,2053,5,12,0,0,2053,
        2055,1,0,0,0,2054,2048,1,0,0,0,2054,2050,1,0,0,0,2055,2058,1,0,0,
        0,2056,2058,3,370,185,0,2057,2047,1,0,0,0,2057,2056,1,0,0,0,2058,
        369,1,0,0,0,2059,2075,3,390,195,0,2060,2061,5,8,0,0,2061,2062,3,
        368,184,0,2062,2063,5,11,0,0,2063,2075,1,0,0,0,2064,2066,5,8,0,0,
        2065,2067,3,364,182,0,2066,2065,1,0,0,0,2066,2067,1,0,0,0,2067,2068,
        1,0,0,0,2068,2075,5,11,0,0,2069,2071,5,9,0,0,2070,2072,3,362,181,
        0,2071,2070,1,0,0,0,2071,2072,1,0,0,0,2072,2073,1,0,0,0,2073,2075,
        5,12,0,0,2074,2059,1,0,0,0,2074,2060,1,0,0,0,2074,2064,1,0,0,0,2074,
        2069,1,0,0,0,2075,371,1,0,0,0,2076,2083,3,374,187,0,2077,2083,3,
        390,195,0,2078,2079,5,8,0,0,2079,2080,3,372,186,0,2080,2081,5,11,
        0,0,2081,2083,1,0,0,0,2082,2076,1,0,0,0,2082,2077,1,0,0,0,2082,2078,
        1,0,0,0,2083,373,1,0,0,0,2084,2091,3,376,188,0,2085,2086,5,14,0,
        0,2086,2092,3,390,195,0,2087,2088,5,9,0,0,2088,2089,3,276,138,0,
        2089,2090,5,12,0,0,2090,2092,1,0,0,0,2091,2085,1,0,0,0,2091,2087,
        1,0,0,0,2092,375,1,0,0,0,2093,2094,6,188,-1,0,2094,2095,3,280,140,
        0,2095,2113,1,0,0,0,2096,2109,10,2,0,0,2097,2098,5,14,0,0,2098,2110,
        3,390,195,0,2099,2100,5,9,0,0,2100,2101,3,276,138,0,2101,2102,5,
        12,0,0,2102,2110,1,0,0,0,2103,2110,3,344,172,0,2104,2106,5,8,0,0,
        2105,2107,3,348,174,0,2106,2105,1,0,0,0,2106,2107,1,0,0,0,2107,2108,
        1,0,0,0,2108,2110,5,11,0,0,2109,2097,1,0,0,0,2109,2099,1,0,0,0,2109,
        2103,1,0,0,0,2109,2104,1,0,0,0,2110,2112,1,0,0,0,2111,2096,1,0,0,
        0,2112,2115,1,0,0,0,2113,2111,1,0,0,0,2113,2114,1,0,0,0,2114,377,
        1,0,0,0,2115,2113,1,0,0,0,2116,2121,3,380,190,0,2117,2118,5,16,0,
        0,2118,2120,3,380,190,0,2119,2117,1,0,0,0,2120,2123,1,0,0,0,2121,
        2119,1,0,0,0,2121,2122,1,0,0,0,2122,2125,1,0,0,0,2123,2121,1,0,0,
        0,2124,2126,5,16,0,0,2125,2124,1,0,0,0,2125,2126,1,0,0,0,2126,379,
        1,0,0,0,2127,2134,3,376,188,0,2128,2129,5,14,0,0,2129,2135,3,390,
        195,0,2130,2131,5,9,0,0,2131,2132,3,276,138,0,2132,2133,5,12,0,0,
        2133,2135,1,0,0,0,2134,2128,1,0,0,0,2134,2130,1,0,0,0,2135,2138,
        1,0,0,0,2136,2138,3,382,191,0,2137,2127,1,0,0,0,2137,2136,1,0,0,
        0,2138,381,1,0,0,0,2139,2155,3,390,195,0,2140,2141,5,8,0,0,2141,
        2142,3,380,190,0,2142,2143,5,11,0,0,2143,2155,1,0,0,0,2144,2146,
        5,8,0,0,2145,2147,3,378,189,0,2146,2145,1,0,0,0,2146,2147,1,0,0,
        0,2147,2148,1,0,0,0,2148,2155,5,11,0,0,2149,2151,5,9,0,0,2150,2152,
        3,378,189,0,2151,2150,1,0,0,0,2151,2152,1,0,0,0,2152,2153,1,0,0,
        0,2153,2155,5,12,0,0,2154,2139,1,0,0,0,2154,2140,1,0,0,0,2154,2144,
        1,0,0,0,2154,2149,1,0,0,0,2155,383,1,0,0,0,2156,2161,3,210,105,0,
        2157,2158,5,16,0,0,2158,2160,3,210,105,0,2159,2157,1,0,0,0,2160,
        2163,1,0,0,0,2161,2159,1,0,0,0,2161,2162,1,0,0,0,2162,2176,1,0,0,
        0,2163,2161,1,0,0,0,2164,2174,5,16,0,0,2165,2166,5,20,0,0,2166,2170,
        3,210,105,0,2167,2168,5,16,0,0,2168,2169,5,36,0,0,2169,2171,3,210,
        105,0,2170,2167,1,0,0,0,2170,2171,1,0,0,0,2171,2175,1,0,0,0,2172,
        2173,5,36,0,0,2173,2175,3,210,105,0,2174,2165,1,0,0,0,2174,2172,
        1,0,0,0,2175,2177,1,0,0,0,2176,2164,1,0,0,0,2176,2177,1,0,0,0,2177,
        2188,1,0,0,0,2178,2179,5,20,0,0,2179,2183,3,210,105,0,2180,2181,
        5,16,0,0,2181,2182,5,36,0,0,2182,2184,3,210,105,0,2183,2180,1,0,
        0,0,2183,2184,1,0,0,0,2184,2188,1,0,0,0,2185,2186,5,36,0,0,2186,
        2188,3,210,105,0,2187,2156,1,0,0,0,2187,2178,1,0,0,0,2187,2185,1,
        0,0,0,2188,385,1,0,0,0,2189,2190,5,98,0,0,2190,2193,5,4,0,0,2191,
        2193,5,4,0,0,2192,2189,1,0,0,0,2192,2191,1,0,0,0,2193,387,1,0,0,
        0,2194,2195,7,5,0,0,2195,389,1,0,0,0,2196,2199,5,94,0,0,2197,2199,
        3,388,194,0,2198,2196,1,0,0,0,2198,2197,1,0,0,0,2199,391,1,0,0,0,
        294,393,403,410,418,426,430,438,445,449,467,477,484,491,497,504,
        508,511,517,519,523,529,535,537,545,554,566,570,579,590,594,599,
        605,612,618,625,631,641,650,658,664,669,673,676,685,690,694,699,
        703,711,715,720,724,728,736,742,746,752,756,761,766,770,775,778,
        781,786,790,795,801,805,812,816,823,827,834,837,840,847,850,854,
        857,862,865,869,872,875,879,899,901,909,911,922,925,933,937,946,
        950,955,967,971,978,986,991,995,1000,1013,1016,1019,1027,1030,1033,
        1035,1041,1043,1053,1070,1077,1080,1085,1095,1099,1110,1121,1129,
        1137,1144,1149,1170,1177,1186,1191,1194,1199,1206,1210,1214,1224,
        1232,1235,1239,1246,1251,1264,1267,1270,1272,1281,1289,1299,1313,
        1317,1321,1324,1329,1334,1336,1352,1356,1364,1367,1373,1375,1382,
        1386,1391,1398,1402,1407,1415,1422,1430,1436,1442,1455,1497,1508,
        1519,1530,1541,1552,1562,1567,1572,1583,1590,1594,1600,1605,1609,
        1613,1615,1618,1622,1626,1628,1631,1642,1646,1652,1655,1660,1666,
        1677,1683,1687,1693,1697,1702,1707,1711,1716,1719,1722,1727,1731,
        1736,1742,1746,1753,1757,1764,1767,1770,1777,1782,1786,1789,1795,
        1800,1803,1806,1817,1822,1828,1837,1839,1843,1851,1853,1863,1872,
        1876,1881,1890,1893,1903,1919,1931,1936,1938,1944,1946,1950,1955,
        1958,1965,1974,1977,1984,1987,1997,2005,2012,2016,2023,2027,2035,
        2038,2040,2045,2054,2057,2066,2071,2074,2082,2091,2106,2109,2113,
        2121,2125,2134,2137,2146,2151,2154,2161,2170,2174,2176,2183,2187,
        2192,2198
    ]

class PythonParser ( Parser ):

    grammarFileName = "PythonParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

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

    symbolicNames = [ "<INVALID>", "ENCODING", "INDENT", "DEDENT", "TYPE_COMMENT", 
                      "FSTRING_START", "FSTRING_MIDDLE", "FSTRING_END", 
                      "LPAR", "LSQB", "LBRACE", "RPAR", "RSQB", "RBRACE", 
                      "DOT", "COLON", "COMMA", "SEMI", "PLUS", "MINUS", 
                      "STAR", "SLASH", "VBAR", "AMPER", "LESS", "GREATER", 
                      "EQUAL", "PERCENT", "EQEQUAL", "NOTEQUAL", "LESSEQUAL", 
                      "GREATEREQUAL", "TILDE", "CIRCUMFLEX", "LEFTSHIFT", 
                      "RIGHTSHIFT", "DOUBLESTAR", "PLUSEQUAL", "MINEQUAL", 
                      "STAREQUAL", "SLASHEQUAL", "PERCENTEQUAL", "AMPEREQUAL", 
                      "VBAREQUAL", "CIRCUMFLEXEQUAL", "LEFTSHIFTEQUAL", 
                      "RIGHTSHIFTEQUAL", "DOUBLESTAREQUAL", "DOUBLESLASH", 
                      "DOUBLESLASHEQUAL", "AT", "ATEQUAL", "RARROW", "ELLIPSIS", 
                      "COLONEQUAL", "EXCLAMATION", "FALSE", "AWAIT", "ELSE", 
                      "IMPORT", "PASS", "NONE", "BREAK", "EXCEPT", "IN", 
                      "RAISE", "TRUE", "CLASS", "FINALLY", "IS", "RETURN", 
                      "AND", "CONTINUE", "FOR", "LAMBDA", "TRY", "AS", "DEF", 
                      "FROM", "NONLOCAL", "WHILE", "ASSERT", "DEL", "GLOBAL", 
                      "NOT", "WITH", "ASYNC", "ELIF", "IF", "OR", "YIELD", 
                      "NAME_OR_TYPE", "NAME_OR_MATCH", "NAME_OR_CASE", "NAME_OR_WILDCARD", 
                      "NAME", "NUMBER", "STRING", "NEWLINE", "COMMENT", 
                      "WS", "EXPLICIT_LINE_JOINING", "ERRORTOKEN" ]

    RULE_file_input = 0
    RULE_interactive = 1
    RULE_eval = 2
    RULE_func_type = 3
    RULE_statements = 4
    RULE_statement = 5
    RULE_statement_newline = 6
    RULE_simple_stmts = 7
    RULE_simple_stmt = 8
    RULE_compound_stmt = 9
    RULE_assignment = 10
    RULE_annotated_rhs = 11
    RULE_augassign = 12
    RULE_return_stmt = 13
    RULE_raise_stmt = 14
    RULE_global_stmt = 15
    RULE_nonlocal_stmt = 16
    RULE_del_stmt = 17
    RULE_yield_stmt = 18
    RULE_assert_stmt = 19
    RULE_import_stmt = 20
    RULE_import_name = 21
    RULE_import_from = 22
    RULE_import_from_targets = 23
    RULE_import_from_as_names = 24
    RULE_import_from_as_name = 25
    RULE_dotted_as_names = 26
    RULE_dotted_as_name = 27
    RULE_dotted_name = 28
    RULE_block = 29
    RULE_decorators = 30
    RULE_class_def = 31
    RULE_class_def_raw = 32
    RULE_function_def = 33
    RULE_function_def_raw = 34
    RULE_params = 35
    RULE_parameters = 36
    RULE_slash_no_default = 37
    RULE_slash_with_default = 38
    RULE_star_etc = 39
    RULE_kwds = 40
    RULE_param_no_default = 41
    RULE_param_no_default_star_annotation = 42
    RULE_param_with_default = 43
    RULE_param_maybe_default = 44
    RULE_param = 45
    RULE_param_star_annotation = 46
    RULE_annotation = 47
    RULE_star_annotation = 48
    RULE_default_assignment = 49
    RULE_if_stmt = 50
    RULE_elif_stmt = 51
    RULE_else_block = 52
    RULE_while_stmt = 53
    RULE_for_stmt = 54
    RULE_with_stmt = 55
    RULE_with_item = 56
    RULE_try_stmt = 57
    RULE_except_block = 58
    RULE_except_star_block = 59
    RULE_finally_block = 60
    RULE_match_stmt = 61
    RULE_subject_expr = 62
    RULE_case_block = 63
    RULE_guard = 64
    RULE_patterns = 65
    RULE_pattern = 66
    RULE_as_pattern = 67
    RULE_or_pattern = 68
    RULE_closed_pattern = 69
    RULE_literal_pattern = 70
    RULE_literal_expr = 71
    RULE_complex_number = 72
    RULE_signed_number = 73
    RULE_signed_real_number = 74
    RULE_real_number = 75
    RULE_imaginary_number = 76
    RULE_capture_pattern = 77
    RULE_pattern_capture_target = 78
    RULE_wildcard_pattern = 79
    RULE_value_pattern = 80
    RULE_attr = 81
    RULE_name_or_attr = 82
    RULE_group_pattern = 83
    RULE_sequence_pattern = 84
    RULE_open_sequence_pattern = 85
    RULE_maybe_sequence_pattern = 86
    RULE_maybe_star_pattern = 87
    RULE_star_pattern = 88
    RULE_mapping_pattern = 89
    RULE_items_pattern = 90
    RULE_key_value_pattern = 91
    RULE_double_star_pattern = 92
    RULE_class_pattern = 93
    RULE_positional_patterns = 94
    RULE_keyword_patterns = 95
    RULE_keyword_pattern = 96
    RULE_type_alias = 97
    RULE_type_params = 98
    RULE_type_param_seq = 99
    RULE_type_param = 100
    RULE_type_param_bound = 101
    RULE_type_param_default = 102
    RULE_type_param_starred_default = 103
    RULE_expressions = 104
    RULE_expression = 105
    RULE_yield_expr = 106
    RULE_star_expressions = 107
    RULE_star_expression = 108
    RULE_star_named_expressions = 109
    RULE_star_named_expression = 110
    RULE_assignment_expression = 111
    RULE_named_expression = 112
    RULE_disjunction = 113
    RULE_conjunction = 114
    RULE_inversion = 115
    RULE_comparison = 116
    RULE_compare_op_bitwise_or_pair = 117
    RULE_eq_bitwise_or = 118
    RULE_noteq_bitwise_or = 119
    RULE_lte_bitwise_or = 120
    RULE_lt_bitwise_or = 121
    RULE_gte_bitwise_or = 122
    RULE_gt_bitwise_or = 123
    RULE_notin_bitwise_or = 124
    RULE_in_bitwise_or = 125
    RULE_isnot_bitwise_or = 126
    RULE_is_bitwise_or = 127
    RULE_bitwise_or = 128
    RULE_bitwise_xor = 129
    RULE_bitwise_and = 130
    RULE_shift_expr = 131
    RULE_sum = 132
    RULE_term = 133
    RULE_factor = 134
    RULE_power = 135
    RULE_await_primary = 136
    RULE_primary = 137
    RULE_slices = 138
    RULE_slice = 139
    RULE_atom = 140
    RULE_group = 141
    RULE_lambdef = 142
    RULE_lambda_params = 143
    RULE_lambda_parameters = 144
    RULE_lambda_slash_no_default = 145
    RULE_lambda_slash_with_default = 146
    RULE_lambda_star_etc = 147
    RULE_lambda_kwds = 148
    RULE_lambda_param_no_default = 149
    RULE_lambda_param_with_default = 150
    RULE_lambda_param_maybe_default = 151
    RULE_lambda_param = 152
    RULE_fstring_middle = 153
    RULE_fstring_replacement_field = 154
    RULE_fstring_conversion = 155
    RULE_fstring_full_format_spec = 156
    RULE_fstring_format_spec = 157
    RULE_fstring = 158
    RULE_string = 159
    RULE_strings = 160
    RULE_list = 161
    RULE_tuple = 162
    RULE_set = 163
    RULE_dict = 164
    RULE_double_starred_kvpairs = 165
    RULE_double_starred_kvpair = 166
    RULE_kvpair = 167
    RULE_for_if_clauses = 168
    RULE_for_if_clause = 169
    RULE_listcomp = 170
    RULE_setcomp = 171
    RULE_genexp = 172
    RULE_dictcomp = 173
    RULE_arguments = 174
    RULE_args = 175
    RULE_kwargs = 176
    RULE_starred_expression = 177
    RULE_kwarg_or_starred = 178
    RULE_kwarg_or_double_starred = 179
    RULE_star_targets = 180
    RULE_star_targets_list_seq = 181
    RULE_star_targets_tuple_seq = 182
    RULE_star_target = 183
    RULE_target_with_star_atom = 184
    RULE_star_atom = 185
    RULE_single_target = 186
    RULE_single_subscript_attribute_target = 187
    RULE_t_primary = 188
    RULE_del_targets = 189
    RULE_del_target = 190
    RULE_del_t_atom = 191
    RULE_type_expressions = 192
    RULE_func_type_comment = 193
    RULE_name_except_underscore = 194
    RULE_name = 195

    ruleNames =  [ "file_input", "interactive", "eval", "func_type", "statements", 
                   "statement", "statement_newline", "simple_stmts", "simple_stmt", 
                   "compound_stmt", "assignment", "annotated_rhs", "augassign", 
                   "return_stmt", "raise_stmt", "global_stmt", "nonlocal_stmt", 
                   "del_stmt", "yield_stmt", "assert_stmt", "import_stmt", 
                   "import_name", "import_from", "import_from_targets", 
                   "import_from_as_names", "import_from_as_name", "dotted_as_names", 
                   "dotted_as_name", "dotted_name", "block", "decorators", 
                   "class_def", "class_def_raw", "function_def", "function_def_raw", 
                   "params", "parameters", "slash_no_default", "slash_with_default", 
                   "star_etc", "kwds", "param_no_default", "param_no_default_star_annotation", 
                   "param_with_default", "param_maybe_default", "param", 
                   "param_star_annotation", "annotation", "star_annotation", 
                   "default_assignment", "if_stmt", "elif_stmt", "else_block", 
                   "while_stmt", "for_stmt", "with_stmt", "with_item", "try_stmt", 
                   "except_block", "except_star_block", "finally_block", 
                   "match_stmt", "subject_expr", "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", "type_alias", 
                   "type_params", "type_param_seq", "type_param", "type_param_bound", 
                   "type_param_default", "type_param_starred_default", "expressions", 
                   "expression", "yield_expr", "star_expressions", "star_expression", 
                   "star_named_expressions", "star_named_expression", "assignment_expression", 
                   "named_expression", "disjunction", "conjunction", "inversion", 
                   "comparison", "compare_op_bitwise_or_pair", "eq_bitwise_or", 
                   "noteq_bitwise_or", "lte_bitwise_or", "lt_bitwise_or", 
                   "gte_bitwise_or", "gt_bitwise_or", "notin_bitwise_or", 
                   "in_bitwise_or", "isnot_bitwise_or", "is_bitwise_or", 
                   "bitwise_or", "bitwise_xor", "bitwise_and", "shift_expr", 
                   "sum", "term", "factor", "power", "await_primary", "primary", 
                   "slices", "slice", "atom", "group", "lambdef", "lambda_params", 
                   "lambda_parameters", "lambda_slash_no_default", "lambda_slash_with_default", 
                   "lambda_star_etc", "lambda_kwds", "lambda_param_no_default", 
                   "lambda_param_with_default", "lambda_param_maybe_default", 
                   "lambda_param", "fstring_middle", "fstring_replacement_field", 
                   "fstring_conversion", "fstring_full_format_spec", "fstring_format_spec", 
                   "fstring", "string", "strings", "list", "tuple", "set", 
                   "dict", "double_starred_kvpairs", "double_starred_kvpair", 
                   "kvpair", "for_if_clauses", "for_if_clause", "listcomp", 
                   "setcomp", "genexp", "dictcomp", "arguments", "args", 
                   "kwargs", "starred_expression", "kwarg_or_starred", "kwarg_or_double_starred", 
                   "star_targets", "star_targets_list_seq", "star_targets_tuple_seq", 
                   "star_target", "target_with_star_atom", "star_atom", 
                   "single_target", "single_subscript_attribute_target", 
                   "t_primary", "del_targets", "del_target", "del_t_atom", 
                   "type_expressions", "func_type_comment", "name_except_underscore", 
                   "name" ]

    EOF = Token.EOF
    ENCODING=1
    INDENT=2
    DEDENT=3
    TYPE_COMMENT=4
    FSTRING_START=5
    FSTRING_MIDDLE=6
    FSTRING_END=7
    LPAR=8
    LSQB=9
    LBRACE=10
    RPAR=11
    RSQB=12
    RBRACE=13
    DOT=14
    COLON=15
    COMMA=16
    SEMI=17
    PLUS=18
    MINUS=19
    STAR=20
    SLASH=21
    VBAR=22
    AMPER=23
    LESS=24
    GREATER=25
    EQUAL=26
    PERCENT=27
    EQEQUAL=28
    NOTEQUAL=29
    LESSEQUAL=30
    GREATEREQUAL=31
    TILDE=32
    CIRCUMFLEX=33
    LEFTSHIFT=34
    RIGHTSHIFT=35
    DOUBLESTAR=36
    PLUSEQUAL=37
    MINEQUAL=38
    STAREQUAL=39
    SLASHEQUAL=40
    PERCENTEQUAL=41
    AMPEREQUAL=42
    VBAREQUAL=43
    CIRCUMFLEXEQUAL=44
    LEFTSHIFTEQUAL=45
    RIGHTSHIFTEQUAL=46
    DOUBLESTAREQUAL=47
    DOUBLESLASH=48
    DOUBLESLASHEQUAL=49
    AT=50
    ATEQUAL=51
    RARROW=52
    ELLIPSIS=53
    COLONEQUAL=54
    EXCLAMATION=55
    FALSE=56
    AWAIT=57
    ELSE=58
    IMPORT=59
    PASS=60
    NONE=61
    BREAK=62
    EXCEPT=63
    IN=64
    RAISE=65
    TRUE=66
    CLASS=67
    FINALLY=68
    IS=69
    RETURN=70
    AND=71
    CONTINUE=72
    FOR=73
    LAMBDA=74
    TRY=75
    AS=76
    DEF=77
    FROM=78
    NONLOCAL=79
    WHILE=80
    ASSERT=81
    DEL=82
    GLOBAL=83
    NOT=84
    WITH=85
    ASYNC=86
    ELIF=87
    IF=88
    OR=89
    YIELD=90
    NAME_OR_TYPE=91
    NAME_OR_MATCH=92
    NAME_OR_CASE=93
    NAME_OR_WILDCARD=94
    NAME=95
    NUMBER=96
    STRING=97
    NEWLINE=98
    COMMENT=99
    WS=100
    EXPLICIT_LINE_JOINING=101
    ERRORTOKEN=102

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




    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(PythonParser.EOF, 0)

        def statements(self):
            return self.getTypedRuleContext(PythonParser.StatementsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_file_input

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




    def file_input(self):

        localctx = PythonParser.File_inputContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_file_input)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 393
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 8873217170123523872) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 8568960935) != 0):
                self.state = 392
                self.statements()


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


    class InteractiveContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement_newline(self):
            return self.getTypedRuleContext(PythonParser.Statement_newlineContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_interactive

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




    def interactive(self):

        localctx = PythonParser.InteractiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_interactive)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 397
            self.statement_newline()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class EvalContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expressions(self):
            return self.getTypedRuleContext(PythonParser.ExpressionsContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_eval

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




    def eval_(self):

        localctx = PythonParser.EvalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_eval)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.expressions()
            self.state = 403
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==98:
                self.state = 400
                self.match(PythonParser.NEWLINE)
                self.state = 405
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Func_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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

        def type_expressions(self):
            return self.getTypedRuleContext(PythonParser.Type_expressionsContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_func_type

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




    def func_type(self):

        localctx = PythonParser.Func_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_func_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.match(PythonParser.LPAR)
            self.state = 410
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531023063598499616) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 409
                self.type_expressions()


            self.state = 412
            self.match(PythonParser.RPAR)
            self.state = 413
            self.match(PythonParser.RARROW)
            self.state = 414
            self.expression()
            self.state = 418
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==98:
                self.state = 415
                self.match(PythonParser.NEWLINE)
                self.state = 420
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class StatementsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_statements

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




    def statements(self):

        localctx = PythonParser.StatementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_statements)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 423
                self.statement()
                self.state = 426 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 8873217170123523872) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 8568960935) != 0)):
                    break

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


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


        def getRuleIndex(self):
            return PythonParser.RULE_statement

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




    def statement(self):

        localctx = PythonParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_statement)
        try:
            self.state = 430
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 428
                self.compound_stmt()
                pass

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


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


    class Statement_newlineContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_statement_newline

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




    def statement_newline(self):

        localctx = PythonParser.Statement_newlineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_statement_newline)
        try:
            self.state = 438
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 432
                self.compound_stmt()
                self.state = 433
                self.match(PythonParser.NEWLINE)
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 436
                self.match(PythonParser.NEWLINE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 437
                self.match(PythonParser.EOF)
                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(PythonParser.Simple_stmtContext)
            else:
                return self.getTypedRuleContext(PythonParser.Simple_stmtContext,i)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_simple_stmts

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




    def simple_stmts(self):

        localctx = PythonParser.Simple_stmtsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_simple_stmts)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 440
            self.simple_stmt()
            self.state = 445
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 441
                    self.match(PythonParser.SEMI)
                    self.state = 442
                    self.simple_stmt() 
                self.state = 447
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

            self.state = 449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==17:
                self.state = 448
                self.match(PythonParser.SEMI)


            self.state = 451
            self.match(PythonParser.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 assignment(self):
            return self.getTypedRuleContext(PythonParser.AssignmentContext,0)


        def type_alias(self):
            return self.getTypedRuleContext(PythonParser.Type_aliasContext,0)


        def star_expressions(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionsContext,0)


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


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


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


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

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


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


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


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

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

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


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


        def getRuleIndex(self):
            return PythonParser.RULE_simple_stmt

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




    def simple_stmt(self):

        localctx = PythonParser.Simple_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_simple_stmt)
        try:
            self.state = 467
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 453
                self.assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 454
                self.type_alias()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 455
                self.star_expressions()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 456
                self.return_stmt()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 457
                self.import_stmt()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 458
                self.raise_stmt()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 459
                self.match(PythonParser.PASS)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 460
                self.del_stmt()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 461
                self.yield_stmt()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 462
                self.assert_stmt()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 463
                self.match(PythonParser.BREAK)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 464
                self.match(PythonParser.CONTINUE)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 465
                self.global_stmt()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 466
                self.nonlocal_stmt()
                pass


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


    class Compound_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def function_def(self):
            return self.getTypedRuleContext(PythonParser.Function_defContext,0)


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


        def class_def(self):
            return self.getTypedRuleContext(PythonParser.Class_defContext,0)


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


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


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


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


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


        def getRuleIndex(self):
            return PythonParser.RULE_compound_stmt

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




    def compound_stmt(self):

        localctx = PythonParser.Compound_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_compound_stmt)
        try:
            self.state = 477
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 469
                self.function_def()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 470
                self.if_stmt()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 471
                self.class_def()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 472
                self.with_stmt()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 473
                self.for_stmt()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 474
                self.try_stmt()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 475
                self.while_stmt()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 476
                self.match_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 AssignmentContext(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(PythonParser.NameContext,0)


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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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

        def annotated_rhs(self):
            return self.getTypedRuleContext(PythonParser.Annotated_rhsContext,0)


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

        def single_target(self):
            return self.getTypedRuleContext(PythonParser.Single_targetContext,0)


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

        def single_subscript_attribute_target(self):
            return self.getTypedRuleContext(PythonParser.Single_subscript_attribute_targetContext,0)


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


        def star_expressions(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionsContext,0)


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


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_assignment

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




    def assignment(self):

        localctx = PythonParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_assignment)
        self._la = 0 # Token type
        try:
            self.state = 519
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 479
                self.name()
                self.state = 480
                self.match(PythonParser.COLON)
                self.state = 481
                self.expression()
                self.state = 484
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 482
                    self.match(PythonParser.EQUAL)
                    self.state = 483
                    self.annotated_rhs()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 491
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                if la_ == 1:
                    self.state = 486
                    self.match(PythonParser.LPAR)
                    self.state = 487
                    self.single_target()
                    self.state = 488
                    self.match(PythonParser.RPAR)
                    pass

                elif la_ == 2:
                    self.state = 490
                    self.single_subscript_attribute_target()
                    pass


                self.state = 493
                self.match(PythonParser.COLON)
                self.state = 494
                self.expression()
                self.state = 497
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 495
                    self.match(PythonParser.EQUAL)
                    self.state = 496
                    self.annotated_rhs()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 502 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 499
                        self.star_targets()
                        self.state = 500
                        self.match(PythonParser.EQUAL)

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

                self.state = 508
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [90]:
                    self.state = 506
                    self.yield_expr()
                    pass
                elif token in [5, 8, 9, 10, 18, 19, 20, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                    self.state = 507
                    self.star_expressions()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 511
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==4:
                    self.state = 510
                    self.match(PythonParser.TYPE_COMMENT)


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 513
                self.single_target()
                self.state = 514
                self.augassign()
                self.state = 517
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [90]:
                    self.state = 515
                    self.yield_expr()
                    pass
                elif token in [5, 8, 9, 10, 18, 19, 20, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                    self.state = 516
                    self.star_expressions()
                    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 Annotated_rhsContext(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(PythonParser.Yield_exprContext,0)


        def star_expressions(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_annotated_rhs

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




    def annotated_rhs(self):

        localctx = PythonParser.Annotated_rhsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_annotated_rhs)
        try:
            self.state = 523
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [90]:
                self.enterOuterAlt(localctx, 1)
                self.state = 521
                self.yield_expr()
                pass
            elif token in [5, 8, 9, 10, 18, 19, 20, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 522
                self.star_expressions()
                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 AugassignContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_augassign

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




    def augassign(self):

        localctx = PythonParser.AugassignContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_augassign)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 525
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 3096087304863744) != 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 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(PythonParser.RETURN, 0)

        def star_expressions(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_return_stmt

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




    def return_stmt(self):

        localctx = PythonParser.Return_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_return_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 527
            self.match(PythonParser.RETURN)
            self.state = 529
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994879022880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 528
                self.star_expressions()


        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(PythonParser.RAISE, 0)

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_raise_stmt

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




    def raise_stmt(self):

        localctx = PythonParser.Raise_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_raise_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531
            self.match(PythonParser.RAISE)
            self.state = 537
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994877974304) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 532
                self.expression()
                self.state = 535
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==78:
                    self.state = 533
                    self.match(PythonParser.FROM)
                    self.state = 534
                    self.expression()




        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(PythonParser.GLOBAL, 0)

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_global_stmt

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




    def global_stmt(self):

        localctx = PythonParser.Global_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_global_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            self.match(PythonParser.GLOBAL)
            self.state = 540
            self.name()
            self.state = 545
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==16:
                self.state = 541
                self.match(PythonParser.COMMA)
                self.state = 542
                self.name()
                self.state = 547
                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(PythonParser.NONLOCAL, 0)

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_nonlocal_stmt

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




    def nonlocal_stmt(self):

        localctx = PythonParser.Nonlocal_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_nonlocal_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 548
            self.match(PythonParser.NONLOCAL)
            self.state = 549
            self.name()
            self.state = 554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==16:
                self.state = 550
                self.match(PythonParser.COMMA)
                self.state = 551
                self.name()
                self.state = 556
                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 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(PythonParser.DEL, 0)

        def del_targets(self):
            return self.getTypedRuleContext(PythonParser.Del_targetsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_del_stmt

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




    def del_stmt(self):

        localctx = PythonParser.Del_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_del_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 557
            self.match(PythonParser.DEL)
            self.state = 558
            self.del_targets()
        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(PythonParser.Yield_exprContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_yield_stmt

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




    def yield_stmt(self):

        localctx = PythonParser.Yield_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_yield_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 560
            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 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(PythonParser.ASSERT, 0)

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_assert_stmt

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




    def assert_stmt(self):

        localctx = PythonParser.Assert_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_assert_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 562
            self.match(PythonParser.ASSERT)
            self.state = 563
            self.expression()
            self.state = 566
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 564
                self.match(PythonParser.COMMA)
                self.state = 565
                self.expression()


        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(PythonParser.Import_nameContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_import_stmt

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




    def import_stmt(self):

        localctx = PythonParser.Import_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_import_stmt)
        try:
            self.state = 570
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [59]:
                self.enterOuterAlt(localctx, 1)
                self.state = 568
                self.import_name()
                pass
            elif token in [78]:
                self.enterOuterAlt(localctx, 2)
                self.state = 569
                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(PythonParser.IMPORT, 0)

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


        def getRuleIndex(self):
            return PythonParser.RULE_import_name

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




    def import_name(self):

        localctx = PythonParser.Import_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_import_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 572
            self.match(PythonParser.IMPORT)
            self.state = 573
            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(PythonParser.FROM, 0)

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


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

        def import_from_targets(self):
            return self.getTypedRuleContext(PythonParser.Import_from_targetsContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_import_from

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




    def import_from(self):

        localctx = PythonParser.Import_fromContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_import_from)
        self._la = 0 # Token type
        try:
            self.state = 594
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 575
                self.match(PythonParser.FROM)
                self.state = 579
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==14 or _la==53:
                    self.state = 576
                    _la = self._input.LA(1)
                    if not(_la==14 or _la==53):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 581
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 582
                self.dotted_name(0)
                self.state = 583
                self.match(PythonParser.IMPORT)
                self.state = 584
                self.import_from_targets()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 586
                self.match(PythonParser.FROM)
                self.state = 588 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 587
                    _la = self._input.LA(1)
                    if not(_la==14 or _la==53):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 590 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==14 or _la==53):
                        break

                self.state = 592
                self.match(PythonParser.IMPORT)
                self.state = 593
                self.import_from_targets()
                pass


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


    class Import_from_targetsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def import_from_as_names(self):
            return self.getTypedRuleContext(PythonParser.Import_from_as_namesContext,0)


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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_import_from_targets

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




    def import_from_targets(self):

        localctx = PythonParser.Import_from_targetsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_import_from_targets)
        self._la = 0 # Token type
        try:
            self.state = 605
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [8]:
                self.enterOuterAlt(localctx, 1)
                self.state = 596
                self.match(PythonParser.LPAR)
                self.state = 597
                self.import_from_as_names()
                self.state = 599
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 598
                    self.match(PythonParser.COMMA)


                self.state = 601
                self.match(PythonParser.RPAR)
                pass
            elif token in [91, 92, 93, 94, 95]:
                self.enterOuterAlt(localctx, 2)
                self.state = 603
                self.import_from_as_names()
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 3)
                self.state = 604
                self.match(PythonParser.STAR)
                pass
            else:
                raise NoViableAltException(self)

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


    class Import_from_as_namesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_import_from_as_names

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




    def import_from_as_names(self):

        localctx = PythonParser.Import_from_as_namesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_import_from_as_names)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607
            self.import_from_as_name()
            self.state = 612
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,32,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 608
                    self.match(PythonParser.COMMA)
                    self.state = 609
                    self.import_from_as_name() 
                self.state = 614
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,32,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 Import_from_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(PythonParser.NameContext)
            else:
                return self.getTypedRuleContext(PythonParser.NameContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_import_from_as_name

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




    def import_from_as_name(self):

        localctx = PythonParser.Import_from_as_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_import_from_as_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 615
            self.name()
            self.state = 618
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==76:
                self.state = 616
                self.match(PythonParser.AS)
                self.state = 617
                self.name()


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


    class Dotted_as_namesContext(ParserRuleContext):
        __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(PythonParser.Dotted_as_nameContext)
            else:
                return self.getTypedRuleContext(PythonParser.Dotted_as_nameContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_dotted_as_names

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




    def dotted_as_names(self):

        localctx = PythonParser.Dotted_as_namesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_dotted_as_names)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 620
            self.dotted_as_name()
            self.state = 625
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==16:
                self.state = 621
                self.match(PythonParser.COMMA)
                self.state = 622
                self.dotted_as_name()
                self.state = 627
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Dotted_as_nameContext(ParserRuleContext):
        __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(PythonParser.Dotted_nameContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_dotted_as_name

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




    def dotted_as_name(self):

        localctx = PythonParser.Dotted_as_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_dotted_as_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 628
            self.dotted_name(0)
            self.state = 631
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==76:
                self.state = 629
                self.match(PythonParser.AS)
                self.state = 630
                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_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.getTypedRuleContext(PythonParser.NameContext,0)


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


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

        def getRuleIndex(self):
            return PythonParser.RULE_dotted_name

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



    def dotted_name(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Dotted_nameContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 56
        self.enterRecursionRule(localctx, 56, self.RULE_dotted_name, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 634
            self.name()
            self._ctx.stop = self._input.LT(-1)
            self.state = 641
            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:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.Dotted_nameContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_dotted_name)
                    self.state = 636
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 637
                    self.match(PythonParser.DOT)
                    self.state = 638
                    self.name() 
                self.state = 643
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,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 BlockContext(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(PythonParser.NEWLINE, 0)

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

        def statements(self):
            return self.getTypedRuleContext(PythonParser.StatementsContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_block

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




    def block(self):

        localctx = PythonParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_block)
        try:
            self.state = 650
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [98]:
                self.enterOuterAlt(localctx, 1)
                self.state = 644
                self.match(PythonParser.NEWLINE)
                self.state = 645
                self.match(PythonParser.INDENT)
                self.state = 646
                self.statements()
                self.state = 647
                self.match(PythonParser.DEDENT)
                pass
            elif token in [5, 8, 9, 10, 18, 19, 20, 32, 53, 56, 57, 59, 60, 61, 62, 65, 66, 70, 72, 74, 78, 79, 81, 82, 83, 84, 90, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 649
                self.simple_stmts()
                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 DecoratorsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_decorators

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




    def decorators(self):

        localctx = PythonParser.DecoratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_decorators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 656 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 652
                self.match(PythonParser.AT)
                self.state = 653
                self.named_expression()
                self.state = 654
                self.match(PythonParser.NEWLINE)
                self.state = 658 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==50):
                    break

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


    class Class_defContext(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(PythonParser.DecoratorsContext,0)


        def class_def_raw(self):
            return self.getTypedRuleContext(PythonParser.Class_def_rawContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_class_def

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




    def class_def(self):

        localctx = PythonParser.Class_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_class_def)
        try:
            self.state = 664
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [50]:
                self.enterOuterAlt(localctx, 1)
                self.state = 660
                self.decorators()
                self.state = 661
                self.class_def_raw()
                pass
            elif token in [67]:
                self.enterOuterAlt(localctx, 2)
                self.state = 663
                self.class_def_raw()
                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 Class_def_rawContext(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(PythonParser.CLASS, 0)

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


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

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


        def type_params(self):
            return self.getTypedRuleContext(PythonParser.Type_paramsContext,0)


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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_class_def_raw

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




    def class_def_raw(self):

        localctx = PythonParser.Class_def_rawContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_class_def_raw)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 666
            self.match(PythonParser.CLASS)
            self.state = 667
            self.name()
            self.state = 669
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 668
                self.type_params()


            self.state = 676
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==8:
                self.state = 671
                self.match(PythonParser.LPAR)
                self.state = 673
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531023063598499616) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                    self.state = 672
                    self.arguments()


                self.state = 675
                self.match(PythonParser.RPAR)


            self.state = 678
            self.match(PythonParser.COLON)
            self.state = 679
            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 Function_defContext(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(PythonParser.DecoratorsContext,0)


        def function_def_raw(self):
            return self.getTypedRuleContext(PythonParser.Function_def_rawContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_function_def

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




    def function_def(self):

        localctx = PythonParser.Function_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_function_def)
        try:
            self.state = 685
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [50]:
                self.enterOuterAlt(localctx, 1)
                self.state = 681
                self.decorators()
                self.state = 682
                self.function_def_raw()
                pass
            elif token in [77, 86]:
                self.enterOuterAlt(localctx, 2)
                self.state = 684
                self.function_def_raw()
                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 Function_def_rawContext(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(PythonParser.DEF, 0)

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


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

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

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

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


        def type_params(self):
            return self.getTypedRuleContext(PythonParser.Type_paramsContext,0)


        def params(self):
            return self.getTypedRuleContext(PythonParser.ParamsContext,0)


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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def func_type_comment(self):
            return self.getTypedRuleContext(PythonParser.Func_type_commentContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_function_def_raw

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




    def function_def_raw(self):

        localctx = PythonParser.Function_def_rawContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_function_def_raw)
        self._la = 0 # Token type
        try:
            self.state = 728
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [77]:
                self.enterOuterAlt(localctx, 1)
                self.state = 687
                self.match(PythonParser.DEF)
                self.state = 688
                self.name()
                self.state = 690
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9:
                    self.state = 689
                    self.type_params()


                self.state = 692
                self.match(PythonParser.LPAR)
                self.state = 694
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36 or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 693
                    self.params()


                self.state = 696
                self.match(PythonParser.RPAR)
                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==52:
                    self.state = 697
                    self.match(PythonParser.RARROW)
                    self.state = 698
                    self.expression()


                self.state = 701
                self.match(PythonParser.COLON)
                self.state = 703
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
                if la_ == 1:
                    self.state = 702
                    self.func_type_comment()


                self.state = 705
                self.block()
                pass
            elif token in [86]:
                self.enterOuterAlt(localctx, 2)
                self.state = 707
                self.match(PythonParser.ASYNC)
                self.state = 708
                self.match(PythonParser.DEF)
                self.state = 709
                self.name()
                self.state = 711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==9:
                    self.state = 710
                    self.type_params()


                self.state = 713
                self.match(PythonParser.LPAR)
                self.state = 715
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36 or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 714
                    self.params()


                self.state = 717
                self.match(PythonParser.RPAR)
                self.state = 720
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==52:
                    self.state = 718
                    self.match(PythonParser.RARROW)
                    self.state = 719
                    self.expression()


                self.state = 722
                self.match(PythonParser.COLON)
                self.state = 724
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                if la_ == 1:
                    self.state = 723
                    self.func_type_comment()


                self.state = 726
                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 ParamsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_params

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




    def params(self):

        localctx = PythonParser.ParamsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_params)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 730
            self.parameters()
        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 slash_no_default(self):
            return self.getTypedRuleContext(PythonParser.Slash_no_defaultContext,0)


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


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


        def star_etc(self):
            return self.getTypedRuleContext(PythonParser.Star_etcContext,0)


        def slash_with_default(self):
            return self.getTypedRuleContext(PythonParser.Slash_with_defaultContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_parameters

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




    def parameters(self):

        localctx = PythonParser.ParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_parameters)
        self._la = 0 # Token type
        try:
            self.state = 781
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 732
                self.slash_no_default()
                self.state = 736
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,53,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 733
                        self.param_no_default() 
                    self.state = 738
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,53,self._ctx)

                self.state = 742
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 739
                    self.param_with_default()
                    self.state = 744
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 745
                    self.star_etc()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 748
                self.slash_with_default()
                self.state = 752
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 749
                    self.param_with_default()
                    self.state = 754
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 756
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 755
                    self.star_etc()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 759 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 758
                        self.param_no_default()

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

                self.state = 766
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 763
                    self.param_with_default()
                    self.state = 768
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 770
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 769
                    self.star_etc()


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 773 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 772
                    self.param_with_default()
                    self.state = 775 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                        break

                self.state = 778
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 777
                    self.star_etc()


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 780
                self.star_etc()
                pass


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


    class Slash_no_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_slash_no_default

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




    def slash_no_default(self):

        localctx = PythonParser.Slash_no_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_slash_no_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 784 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 783
                self.param_no_default()
                self.state = 786 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                    break

            self.state = 788
            self.match(PythonParser.SLASH)
            self.state = 790
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 789
                self.match(PythonParser.COMMA)


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


    class Slash_with_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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

        def getRuleIndex(self):
            return PythonParser.RULE_slash_with_default

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




    def slash_with_default(self):

        localctx = PythonParser.Slash_with_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_slash_with_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 795
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,66,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 792
                    self.param_no_default() 
                self.state = 797
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,66,self._ctx)

            self.state = 799 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 798
                self.param_with_default()
                self.state = 801 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                    break

            self.state = 803
            self.match(PythonParser.SLASH)
            self.state = 805
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 804
                self.match(PythonParser.COMMA)


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


    class Star_etcContext(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(PythonParser.STAR, 0)

        def param_no_default(self):
            return self.getTypedRuleContext(PythonParser.Param_no_defaultContext,0)


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


        def kwds(self):
            return self.getTypedRuleContext(PythonParser.KwdsContext,0)


        def param_no_default_star_annotation(self):
            return self.getTypedRuleContext(PythonParser.Param_no_default_star_annotationContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_star_etc

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




    def star_etc(self):

        localctx = PythonParser.Star_etcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_star_etc)
        self._la = 0 # Token type
        try:
            self.state = 840
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 807
                self.match(PythonParser.STAR)
                self.state = 808
                self.param_no_default()
                self.state = 812
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 809
                    self.param_maybe_default()
                    self.state = 814
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 816
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==36:
                    self.state = 815
                    self.kwds()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 818
                self.match(PythonParser.STAR)
                self.state = 819
                self.param_no_default_star_annotation()
                self.state = 823
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 820
                    self.param_maybe_default()
                    self.state = 825
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 827
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==36:
                    self.state = 826
                    self.kwds()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 829
                self.match(PythonParser.STAR)
                self.state = 830
                self.match(PythonParser.COMMA)
                self.state = 832 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 831
                    self.param_maybe_default()
                    self.state = 834 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                        break

                self.state = 837
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==36:
                    self.state = 836
                    self.kwds()


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 839
                self.kwds()
                pass


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


    class KwdsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def param_no_default(self):
            return self.getTypedRuleContext(PythonParser.Param_no_defaultContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_kwds

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




    def kwds(self):

        localctx = PythonParser.KwdsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_kwds)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 842
            self.match(PythonParser.DOUBLESTAR)
            self.state = 843
            self.param_no_default()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Param_no_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def param(self):
            return self.getTypedRuleContext(PythonParser.ParamContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_param_no_default

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




    def param_no_default(self):

        localctx = PythonParser.Param_no_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_param_no_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 845
            self.param()
            self.state = 847
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 846
                self.match(PythonParser.COMMA)


            self.state = 850
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 849
                self.match(PythonParser.TYPE_COMMENT)


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


    class Param_no_default_star_annotationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def param_star_annotation(self):
            return self.getTypedRuleContext(PythonParser.Param_star_annotationContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_param_no_default_star_annotation

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




    def param_no_default_star_annotation(self):

        localctx = PythonParser.Param_no_default_star_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_param_no_default_star_annotation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 852
            self.param_star_annotation()
            self.state = 854
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 853
                self.match(PythonParser.COMMA)


            self.state = 857
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 856
                self.match(PythonParser.TYPE_COMMENT)


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


    class Param_with_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def param(self):
            return self.getTypedRuleContext(PythonParser.ParamContext,0)


        def default_assignment(self):
            return self.getTypedRuleContext(PythonParser.Default_assignmentContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_param_with_default

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




    def param_with_default(self):

        localctx = PythonParser.Param_with_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_param_with_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 859
            self.param()
            self.state = 860
            self.default_assignment()
            self.state = 862
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 861
                self.match(PythonParser.COMMA)


            self.state = 865
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 864
                self.match(PythonParser.TYPE_COMMENT)


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


    class Param_maybe_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def param(self):
            return self.getTypedRuleContext(PythonParser.ParamContext,0)


        def default_assignment(self):
            return self.getTypedRuleContext(PythonParser.Default_assignmentContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_param_maybe_default

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




    def param_maybe_default(self):

        localctx = PythonParser.Param_maybe_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_param_maybe_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 867
            self.param()
            self.state = 869
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26:
                self.state = 868
                self.default_assignment()


            self.state = 872
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 871
                self.match(PythonParser.COMMA)


            self.state = 875
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 874
                self.match(PythonParser.TYPE_COMMENT)


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


    class ParamContext(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(PythonParser.NameContext,0)


        def annotation(self):
            return self.getTypedRuleContext(PythonParser.AnnotationContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_param

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




    def param(self):

        localctx = PythonParser.ParamContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_param)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 877
            self.name()
            self.state = 879
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==15:
                self.state = 878
                self.annotation()


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


    class Param_star_annotationContext(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(PythonParser.NameContext,0)


        def star_annotation(self):
            return self.getTypedRuleContext(PythonParser.Star_annotationContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_param_star_annotation

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




    def param_star_annotation(self):

        localctx = PythonParser.Param_star_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_param_star_annotation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 881
            self.name()
            self.state = 882
            self.star_annotation()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AnnotationContext(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(PythonParser.COLON, 0)

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_annotation

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




    def annotation(self):

        localctx = PythonParser.AnnotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_annotation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 884
            self.match(PythonParser.COLON)
            self.state = 885
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Star_annotationContext(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(PythonParser.COLON, 0)

        def star_expression(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_star_annotation

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




    def star_annotation(self):

        localctx = PythonParser.Star_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_star_annotation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 887
            self.match(PythonParser.COLON)
            self.state = 888
            self.star_expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Default_assignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_default_assignment

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




    def default_assignment(self):

        localctx = PythonParser.Default_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_default_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 890
            self.match(PythonParser.EQUAL)
            self.state = 891
            self.expression()
        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(PythonParser.IF, 0)

        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


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

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


        def elif_stmt(self):
            return self.getTypedRuleContext(PythonParser.Elif_stmtContext,0)


        def else_block(self):
            return self.getTypedRuleContext(PythonParser.Else_blockContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_if_stmt

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




    def if_stmt(self):

        localctx = PythonParser.If_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_if_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 893
            self.match(PythonParser.IF)
            self.state = 894
            self.named_expression()
            self.state = 895
            self.match(PythonParser.COLON)
            self.state = 896
            self.block()
            self.state = 901
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [87]:
                self.state = 897
                self.elif_stmt()
                pass
            elif token in [-1, 3, 5, 8, 9, 10, 18, 19, 20, 32, 50, 53, 56, 57, 58, 59, 60, 61, 62, 65, 66, 67, 70, 72, 73, 74, 75, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 88, 90, 91, 92, 93, 94, 95, 96, 97, 98]:
                self.state = 899
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==58:
                    self.state = 898
                    self.else_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 Elif_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


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

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


        def elif_stmt(self):
            return self.getTypedRuleContext(PythonParser.Elif_stmtContext,0)


        def else_block(self):
            return self.getTypedRuleContext(PythonParser.Else_blockContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_elif_stmt

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




    def elif_stmt(self):

        localctx = PythonParser.Elif_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_elif_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 903
            self.match(PythonParser.ELIF)
            self.state = 904
            self.named_expression()
            self.state = 905
            self.match(PythonParser.COLON)
            self.state = 906
            self.block()
            self.state = 911
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [87]:
                self.state = 907
                self.elif_stmt()
                pass
            elif token in [-1, 3, 5, 8, 9, 10, 18, 19, 20, 32, 50, 53, 56, 57, 58, 59, 60, 61, 62, 65, 66, 67, 70, 72, 73, 74, 75, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 88, 90, 91, 92, 93, 94, 95, 96, 97, 98]:
                self.state = 909
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==58:
                    self.state = 908
                    self.else_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 Else_blockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_else_block

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




    def else_block(self):

        localctx = PythonParser.Else_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_else_block)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 913
            self.match(PythonParser.ELSE)
            self.state = 914
            self.match(PythonParser.COLON)
            self.state = 915
            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(PythonParser.WHILE, 0)

        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


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

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


        def else_block(self):
            return self.getTypedRuleContext(PythonParser.Else_blockContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_while_stmt

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




    def while_stmt(self):

        localctx = PythonParser.While_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_while_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 917
            self.match(PythonParser.WHILE)
            self.state = 918
            self.named_expression()
            self.state = 919
            self.match(PythonParser.COLON)
            self.state = 920
            self.block()
            self.state = 922
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==58:
                self.state = 921
                self.else_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(PythonParser.FOR, 0)

        def star_targets(self):
            return self.getTypedRuleContext(PythonParser.Star_targetsContext,0)


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

        def star_expressions(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionsContext,0)


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

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


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

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

        def else_block(self):
            return self.getTypedRuleContext(PythonParser.Else_blockContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_for_stmt

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




    def for_stmt(self):

        localctx = PythonParser.For_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_for_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 925
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==86:
                self.state = 924
                self.match(PythonParser.ASYNC)


            self.state = 927
            self.match(PythonParser.FOR)
            self.state = 928
            self.star_targets()
            self.state = 929
            self.match(PythonParser.IN)
            self.state = 930
            self.star_expressions()
            self.state = 931
            self.match(PythonParser.COLON)
            self.state = 933
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 932
                self.match(PythonParser.TYPE_COMMENT)


            self.state = 935
            self.block()
            self.state = 937
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==58:
                self.state = 936
                self.else_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_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(PythonParser.WITH, 0)

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

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


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

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

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


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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_with_stmt

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




    def with_stmt(self):

        localctx = PythonParser.With_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_with_stmt)
        self._la = 0 # Token type
        try:
            self.state = 995
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 939
                self.match(PythonParser.WITH)
                self.state = 940
                self.match(PythonParser.LPAR)
                self.state = 941
                self.with_item()
                self.state = 946
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,94,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 942
                        self.match(PythonParser.COMMA)
                        self.state = 943
                        self.with_item() 
                    self.state = 948
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,94,self._ctx)

                self.state = 950
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 949
                    self.match(PythonParser.COMMA)


                self.state = 952
                self.match(PythonParser.RPAR)
                self.state = 953
                self.match(PythonParser.COLON)
                self.state = 955
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==4:
                    self.state = 954
                    self.match(PythonParser.TYPE_COMMENT)


                self.state = 957
                self.block()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 959
                self.match(PythonParser.ASYNC)
                self.state = 960
                self.match(PythonParser.WITH)
                self.state = 961
                self.match(PythonParser.LPAR)
                self.state = 962
                self.with_item()
                self.state = 967
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,97,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 963
                        self.match(PythonParser.COMMA)
                        self.state = 964
                        self.with_item() 
                    self.state = 969
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,97,self._ctx)

                self.state = 971
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 970
                    self.match(PythonParser.COMMA)


                self.state = 973
                self.match(PythonParser.RPAR)
                self.state = 974
                self.match(PythonParser.COLON)
                self.state = 975
                self.block()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 978
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==86:
                    self.state = 977
                    self.match(PythonParser.ASYNC)


                self.state = 980
                self.match(PythonParser.WITH)
                self.state = 981
                self.with_item()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==16:
                    self.state = 982
                    self.match(PythonParser.COMMA)
                    self.state = 983
                    self.with_item()
                    self.state = 988
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 989
                self.match(PythonParser.COLON)
                self.state = 991
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==4:
                    self.state = 990
                    self.match(PythonParser.TYPE_COMMENT)


                self.state = 993
                self.block()
                pass


        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 expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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

        def star_target(self):
            return self.getTypedRuleContext(PythonParser.Star_targetContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_with_item

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




    def with_item(self):

        localctx = PythonParser.With_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_with_item)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 997
            self.expression()
            self.state = 1000
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==76:
                self.state = 998
                self.match(PythonParser.AS)
                self.state = 999
                self.star_target()


        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(PythonParser.TRY, 0)

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

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


        def finally_block(self):
            return self.getTypedRuleContext(PythonParser.Finally_blockContext,0)


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


        def else_block(self):
            return self.getTypedRuleContext(PythonParser.Else_blockContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_try_stmt

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




    def try_stmt(self):

        localctx = PythonParser.Try_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_try_stmt)
        self._la = 0 # Token type
        try:
            self.state = 1035
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1002
                self.match(PythonParser.TRY)
                self.state = 1003
                self.match(PythonParser.COLON)
                self.state = 1004
                self.block()
                self.state = 1005
                self.finally_block()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1007
                self.match(PythonParser.TRY)
                self.state = 1008
                self.match(PythonParser.COLON)
                self.state = 1009
                self.block()
                self.state = 1011 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1010
                    self.except_block()
                    self.state = 1013 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==63):
                        break

                self.state = 1016
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==58:
                    self.state = 1015
                    self.else_block()


                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 1018
                    self.finally_block()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1021
                self.match(PythonParser.TRY)
                self.state = 1022
                self.match(PythonParser.COLON)
                self.state = 1023
                self.block()
                self.state = 1025 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1024
                    self.except_star_block()
                    self.state = 1027 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==63):
                        break

                self.state = 1030
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==58:
                    self.state = 1029
                    self.else_block()


                self.state = 1033
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==68:
                    self.state = 1032
                    self.finally_block()


                pass


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


    class Except_blockContext(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(PythonParser.EXCEPT, 0)

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

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


        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_except_block

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




    def except_block(self):

        localctx = PythonParser.Except_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_except_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1037
            self.match(PythonParser.EXCEPT)
            self.state = 1043
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994877974304) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 1038
                self.expression()
                self.state = 1041
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==76:
                    self.state = 1039
                    self.match(PythonParser.AS)
                    self.state = 1040
                    self.name()




            self.state = 1045
            self.match(PythonParser.COLON)
            self.state = 1046
            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 Except_star_blockContext(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(PythonParser.EXCEPT, 0)

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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

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


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_except_star_block

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




    def except_star_block(self):

        localctx = PythonParser.Except_star_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_except_star_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1048
            self.match(PythonParser.EXCEPT)
            self.state = 1049
            self.match(PythonParser.STAR)
            self.state = 1050
            self.expression()
            self.state = 1053
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==76:
                self.state = 1051
                self.match(PythonParser.AS)
                self.state = 1052
                self.name()


            self.state = 1055
            self.match(PythonParser.COLON)
            self.state = 1056
            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 Finally_blockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_finally_block

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




    def finally_block(self):

        localctx = PythonParser.Finally_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_finally_block)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1058
            self.match(PythonParser.FINALLY)
            self.state = 1059
            self.match(PythonParser.COLON)
            self.state = 1060
            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 Match_stmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

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

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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_match_stmt

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




    def match_stmt(self):

        localctx = PythonParser.Match_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_match_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1062
            self.match(PythonParser.NAME_OR_MATCH)
            self.state = 1063
            self.subject_expr()
            self.state = 1064
            self.match(PythonParser.COLON)
            self.state = 1065
            self.match(PythonParser.NEWLINE)
            self.state = 1066
            self.match(PythonParser.INDENT)
            self.state = 1068 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1067
                self.case_block()
                self.state = 1070 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==93):
                    break

            self.state = 1072
            self.match(PythonParser.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(PythonParser.Star_named_expressionContext,0)


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

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


        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_subject_expr

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




    def subject_expr(self):

        localctx = PythonParser.Subject_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_subject_expr)
        self._la = 0 # Token type
        try:
            self.state = 1080
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1074
                self.star_named_expression()
                self.state = 1075
                self.match(PythonParser.COMMA)
                self.state = 1077
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994879022880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                    self.state = 1076
                    self.star_named_expressions()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1079
                self.named_expression()
                pass


        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 NAME_OR_CASE(self):
            return self.getToken(PythonParser.NAME_OR_CASE, 0)

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


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

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


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


        def getRuleIndex(self):
            return PythonParser.RULE_case_block

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




    def case_block(self):

        localctx = PythonParser.Case_blockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_case_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1082
            self.match(PythonParser.NAME_OR_CASE)
            self.state = 1083
            self.patterns()
            self.state = 1085
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==88:
                self.state = 1084
                self.guard()


            self.state = 1087
            self.match(PythonParser.COLON)
            self.state = 1088
            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(PythonParser.IF, 0)

        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_guard

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




    def guard(self):

        localctx = PythonParser.GuardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_guard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1090
            self.match(PythonParser.IF)
            self.state = 1091
            self.named_expression()
        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(PythonParser.Open_sequence_patternContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_patterns

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




    def patterns(self):

        localctx = PythonParser.PatternsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_patterns)
        try:
            self.state = 1095
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,118,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1093
                self.open_sequence_pattern()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1094
                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(PythonParser.As_patternContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_pattern

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




    def pattern(self):

        localctx = PythonParser.PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_pattern)
        try:
            self.state = 1099
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1097
                self.as_pattern()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1098
                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(PythonParser.Or_patternContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_as_pattern

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




    def as_pattern(self):

        localctx = PythonParser.As_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_as_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1101
            self.or_pattern()
            self.state = 1102
            self.match(PythonParser.AS)
            self.state = 1103
            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(PythonParser.Closed_patternContext)
            else:
                return self.getTypedRuleContext(PythonParser.Closed_patternContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_or_pattern

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




    def or_pattern(self):

        localctx = PythonParser.Or_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_or_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1105
            self.closed_pattern()
            self.state = 1110
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==22:
                self.state = 1106
                self.match(PythonParser.VBAR)
                self.state = 1107
                self.closed_pattern()
                self.state = 1112
                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(PythonParser.Literal_patternContext,0)


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


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


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


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


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


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


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


        def getRuleIndex(self):
            return PythonParser.RULE_closed_pattern

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




    def closed_pattern(self):

        localctx = PythonParser.Closed_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_closed_pattern)
        try:
            self.state = 1121
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1113
                self.literal_pattern()
                pass

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

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

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

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

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

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

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1120
                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(PythonParser.Signed_numberContext,0)


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


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


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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_literal_pattern

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




    def literal_pattern(self):

        localctx = PythonParser.Literal_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_literal_pattern)
        try:
            self.state = 1129
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1123
                self.signed_number()
                pass

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

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

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

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

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1128
                self.match(PythonParser.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(PythonParser.Signed_numberContext,0)


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


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


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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_literal_expr

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




    def literal_expr(self):

        localctx = PythonParser.Literal_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_literal_expr)
        try:
            self.state = 1137
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1131
                self.signed_number()
                pass

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

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

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

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

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1136
                self.match(PythonParser.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(PythonParser.Signed_real_numberContext,0)


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


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_complex_number

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




    def complex_number(self):

        localctx = PythonParser.Complex_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_complex_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1139
            self.signed_real_number()
            self.state = 1140
            _la = self._input.LA(1)
            if not(_la==18 or _la==19):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1141
            self.imaginary_number()
        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(PythonParser.NUMBER, 0)

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

        def getRuleIndex(self):
            return PythonParser.RULE_signed_number

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




    def signed_number(self):

        localctx = PythonParser.Signed_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_signed_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1144
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19:
                self.state = 1143
                self.match(PythonParser.MINUS)


            self.state = 1146
            self.match(PythonParser.NUMBER)
        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(PythonParser.Real_numberContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_signed_real_number

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




    def signed_real_number(self):

        localctx = PythonParser.Signed_real_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_signed_real_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1149
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19:
                self.state = 1148
                self.match(PythonParser.MINUS)


            self.state = 1151
            self.real_number()
        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(PythonParser.NUMBER, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_real_number

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




    def real_number(self):

        localctx = PythonParser.Real_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_real_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1153
            self.match(PythonParser.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(PythonParser.NUMBER, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_imaginary_number

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




    def imaginary_number(self):

        localctx = PythonParser.Imaginary_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_imaginary_number)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1155
            self.match(PythonParser.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(PythonParser.Pattern_capture_targetContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_capture_pattern

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




    def capture_pattern(self):

        localctx = PythonParser.Capture_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_capture_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1157
            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_except_underscore(self):
            return self.getTypedRuleContext(PythonParser.Name_except_underscoreContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_pattern_capture_target

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




    def pattern_capture_target(self):

        localctx = PythonParser.Pattern_capture_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_pattern_capture_target)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1159
            self.name_except_underscore()
        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 NAME_OR_WILDCARD(self):
            return self.getToken(PythonParser.NAME_OR_WILDCARD, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_wildcard_pattern

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




    def wildcard_pattern(self):

        localctx = PythonParser.Wildcard_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_wildcard_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1161
            self.match(PythonParser.NAME_OR_WILDCARD)
        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(PythonParser.AttrContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_value_pattern

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




    def value_pattern(self):

        localctx = PythonParser.Value_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_value_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1163
            self.attr()
        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(PythonParser.NameContext)
            else:
                return self.getTypedRuleContext(PythonParser.NameContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_attr

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




    def attr(self):

        localctx = PythonParser.AttrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_attr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1165
            self.name()
            self.state = 1168 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1166
                self.match(PythonParser.DOT)
                self.state = 1167
                self.name()
                self.state = 1170 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==14):
                    break

        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 name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.NameContext)
            else:
                return self.getTypedRuleContext(PythonParser.NameContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_name_or_attr

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




    def name_or_attr(self):

        localctx = PythonParser.Name_or_attrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_name_or_attr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1172
            self.name()
            self.state = 1177
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==14:
                self.state = 1173
                self.match(PythonParser.DOT)
                self.state = 1174
                self.name()
                self.state = 1179
                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 Group_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_group_pattern

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




    def group_pattern(self):

        localctx = PythonParser.Group_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_group_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1180
            self.match(PythonParser.LPAR)
            self.state = 1181
            self.pattern()
            self.state = 1182
            self.match(PythonParser.RPAR)
        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 LSQB(self):
            return self.getToken(PythonParser.LSQB, 0)

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

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


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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_sequence_pattern

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




    def sequence_pattern(self):

        localctx = PythonParser.Sequence_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_sequence_pattern)
        self._la = 0 # Token type
        try:
            self.state = 1194
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1184
                self.match(PythonParser.LSQB)
                self.state = 1186
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377900603253196576) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                    self.state = 1185
                    self.maybe_sequence_pattern()


                self.state = 1188
                self.match(PythonParser.RSQB)
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1189
                self.match(PythonParser.LPAR)
                self.state = 1191
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377900603253196576) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                    self.state = 1190
                    self.open_sequence_pattern()


                self.state = 1193
                self.match(PythonParser.RPAR)
                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(PythonParser.Maybe_star_patternContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_open_sequence_pattern

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




    def open_sequence_pattern(self):

        localctx = PythonParser.Open_sequence_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_open_sequence_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1196
            self.maybe_star_pattern()
            self.state = 1197
            self.match(PythonParser.COMMA)
            self.state = 1199
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377900603253196576) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                self.state = 1198
                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(PythonParser.Maybe_star_patternContext)
            else:
                return self.getTypedRuleContext(PythonParser.Maybe_star_patternContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_maybe_sequence_pattern

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




    def maybe_sequence_pattern(self):

        localctx = PythonParser.Maybe_sequence_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_maybe_sequence_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1201
            self.maybe_star_pattern()
            self.state = 1206
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,132,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1202
                    self.match(PythonParser.COMMA)
                    self.state = 1203
                    self.maybe_star_pattern() 
                self.state = 1208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,132,self._ctx)

            self.state = 1210
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1209
                self.match(PythonParser.COMMA)


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


    class 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(PythonParser.Star_patternContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_maybe_star_pattern

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




    def maybe_star_pattern(self):

        localctx = PythonParser.Maybe_star_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_maybe_star_pattern)
        try:
            self.state = 1214
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1212
                self.star_pattern()
                pass
            elif token in [5, 8, 9, 10, 19, 56, 61, 66, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1213
                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(PythonParser.STAR, 0)

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


        def getRuleIndex(self):
            return PythonParser.RULE_star_pattern

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




    def star_pattern(self):

        localctx = PythonParser.Star_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_star_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1216
            self.match(PythonParser.STAR)
            self.state = 1217
            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 Mapping_patternContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_mapping_pattern

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




    def mapping_pattern(self):

        localctx = PythonParser.Mapping_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_mapping_pattern)
        self._la = 0 # Token type
        try:
            self.state = 1239
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,138,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1219
                self.match(PythonParser.LBRACE)
                self.state = 1220
                self.match(PythonParser.RBRACE)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1221
                self.match(PythonParser.LBRACE)
                self.state = 1222
                self.double_star_pattern()
                self.state = 1224
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 1223
                    self.match(PythonParser.COMMA)


                self.state = 1226
                self.match(PythonParser.RBRACE)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1228
                self.match(PythonParser.LBRACE)
                self.state = 1229
                self.items_pattern()
                self.state = 1232
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,136,self._ctx)
                if la_ == 1:
                    self.state = 1230
                    self.match(PythonParser.COMMA)
                    self.state = 1231
                    self.double_star_pattern()


                self.state = 1235
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 1234
                    self.match(PythonParser.COMMA)


                self.state = 1237
                self.match(PythonParser.RBRACE)
                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(PythonParser.Key_value_patternContext)
            else:
                return self.getTypedRuleContext(PythonParser.Key_value_patternContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_items_pattern

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




    def items_pattern(self):

        localctx = PythonParser.Items_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_items_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1241
            self.key_value_pattern()
            self.state = 1246
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,139,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1242
                    self.match(PythonParser.COMMA)
                    self.state = 1243
                    self.key_value_pattern() 
                self.state = 1248
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,139,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(PythonParser.COLON, 0)

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


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


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


        def getRuleIndex(self):
            return PythonParser.RULE_key_value_pattern

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




    def key_value_pattern(self):

        localctx = PythonParser.Key_value_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_key_value_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1251
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 19, 56, 61, 66, 96, 97]:
                self.state = 1249
                self.literal_expr()
                pass
            elif token in [91, 92, 93, 94, 95]:
                self.state = 1250
                self.attr()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1253
            self.match(PythonParser.COLON)
            self.state = 1254
            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 DOUBLESTAR(self):
            return self.getToken(PythonParser.DOUBLESTAR, 0)

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


        def getRuleIndex(self):
            return PythonParser.RULE_double_star_pattern

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




    def double_star_pattern(self):

        localctx = PythonParser.Double_star_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_double_star_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1256
            self.match(PythonParser.DOUBLESTAR)
            self.state = 1257
            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(PythonParser.Name_or_attrContext,0)


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

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

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


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


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

        def getRuleIndex(self):
            return PythonParser.RULE_class_pattern

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




    def class_pattern(self):

        localctx = PythonParser.Class_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_class_pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1259
            self.name_or_attr()
            self.state = 1260
            self.match(PythonParser.LPAR)
            self.state = 1272
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377900603252148000) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                self.state = 1267
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,142,self._ctx)
                if la_ == 1:
                    self.state = 1261
                    self.positional_patterns()
                    self.state = 1264
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,141,self._ctx)
                    if la_ == 1:
                        self.state = 1262
                        self.match(PythonParser.COMMA)
                        self.state = 1263
                        self.keyword_patterns()


                    pass

                elif la_ == 2:
                    self.state = 1266
                    self.keyword_patterns()
                    pass


                self.state = 1270
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 1269
                    self.match(PythonParser.COMMA)




            self.state = 1274
            self.match(PythonParser.RPAR)
        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(PythonParser.PatternContext)
            else:
                return self.getTypedRuleContext(PythonParser.PatternContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_positional_patterns

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




    def positional_patterns(self):

        localctx = PythonParser.Positional_patternsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_positional_patterns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1276
            self.pattern()
            self.state = 1281
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1277
                    self.match(PythonParser.COMMA)
                    self.state = 1278
                    self.pattern() 
                self.state = 1283
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,145,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(PythonParser.Keyword_patternContext)
            else:
                return self.getTypedRuleContext(PythonParser.Keyword_patternContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_keyword_patterns

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




    def keyword_patterns(self):

        localctx = PythonParser.Keyword_patternsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_keyword_patterns)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1284
            self.keyword_pattern()
            self.state = 1289
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,146,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1285
                    self.match(PythonParser.COMMA)
                    self.state = 1286
                    self.keyword_pattern() 
                self.state = 1291
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,146,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(PythonParser.NameContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_keyword_pattern

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




    def keyword_pattern(self):

        localctx = PythonParser.Keyword_patternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_keyword_pattern)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1292
            self.name()
            self.state = 1293
            self.match(PythonParser.EQUAL)
            self.state = 1294
            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 Type_aliasContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def type_params(self):
            return self.getTypedRuleContext(PythonParser.Type_paramsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_type_alias

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




    def type_alias(self):

        localctx = PythonParser.Type_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_type_alias)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1296
            self.match(PythonParser.NAME_OR_TYPE)
            self.state = 1297
            self.name()
            self.state = 1299
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==9:
                self.state = 1298
                self.type_params()


            self.state = 1301
            self.match(PythonParser.EQUAL)
            self.state = 1302
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def type_param_seq(self):
            return self.getTypedRuleContext(PythonParser.Type_param_seqContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_type_params

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




    def type_params(self):

        localctx = PythonParser.Type_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_type_params)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1304
            self.match(PythonParser.LSQB)
            self.state = 1305
            self.type_param_seq()
            self.state = 1306
            self.match(PythonParser.RSQB)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_param_seqContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_type_param_seq

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




    def type_param_seq(self):

        localctx = PythonParser.Type_param_seqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_type_param_seq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1308
            self.type_param()
            self.state = 1313
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,148,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1309
                    self.match(PythonParser.COMMA)
                    self.state = 1310
                    self.type_param() 
                self.state = 1315
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,148,self._ctx)

            self.state = 1317
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1316
                self.match(PythonParser.COMMA)


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


    class Type_paramContext(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(PythonParser.NameContext,0)


        def type_param_bound(self):
            return self.getTypedRuleContext(PythonParser.Type_param_boundContext,0)


        def type_param_default(self):
            return self.getTypedRuleContext(PythonParser.Type_param_defaultContext,0)


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

        def type_param_starred_default(self):
            return self.getTypedRuleContext(PythonParser.Type_param_starred_defaultContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_type_param

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




    def type_param(self):

        localctx = PythonParser.Type_paramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_type_param)
        self._la = 0 # Token type
        try:
            self.state = 1336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [91, 92, 93, 94, 95]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1319
                self.name()
                self.state = 1321
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==15:
                    self.state = 1320
                    self.type_param_bound()


                self.state = 1324
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 1323
                    self.type_param_default()


                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1326
                self.match(PythonParser.STAR)
                self.state = 1327
                self.name()
                self.state = 1329
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 1328
                    self.type_param_starred_default()


                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1331
                self.match(PythonParser.DOUBLESTAR)
                self.state = 1332
                self.name()
                self.state = 1334
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==26:
                    self.state = 1333
                    self.type_param_default()


                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 Type_param_boundContext(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(PythonParser.COLON, 0)

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_type_param_bound

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




    def type_param_bound(self):

        localctx = PythonParser.Type_param_boundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_type_param_bound)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1338
            self.match(PythonParser.COLON)
            self.state = 1339
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_param_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_type_param_default

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




    def type_param_default(self):

        localctx = PythonParser.Type_param_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_type_param_default)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1341
            self.match(PythonParser.EQUAL)
            self.state = 1342
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_param_starred_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def star_expression(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_type_param_starred_default

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




    def type_param_starred_default(self):

        localctx = PythonParser.Type_param_starred_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_type_param_starred_default)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1344
            self.match(PythonParser.EQUAL)
            self.state = 1345
            self.star_expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_expressions

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




    def expressions(self):

        localctx = PythonParser.ExpressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_expressions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1347
            self.expression()
            self.state = 1352
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,155,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1348
                    self.match(PythonParser.COMMA)
                    self.state = 1349
                    self.expression() 
                self.state = 1354
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,155,self._ctx)

            self.state = 1356
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1355
                self.match(PythonParser.COMMA)


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


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_expression

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




    def expression(self):

        localctx = PythonParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.state = 1367
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1358
                self.disjunction()
                self.state = 1364
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==88:
                    self.state = 1359
                    self.match(PythonParser.IF)
                    self.state = 1360
                    self.disjunction()
                    self.state = 1361
                    self.match(PythonParser.ELSE)
                    self.state = 1362
                    self.expression()


                pass
            elif token in [74]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1366
                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 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(PythonParser.YIELD, 0)

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def star_expressions(self):
            return self.getTypedRuleContext(PythonParser.Star_expressionsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_yield_expr

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




    def yield_expr(self):

        localctx = PythonParser.Yield_exprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_yield_expr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1369
            self.match(PythonParser.YIELD)
            self.state = 1375
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [78]:
                self.state = 1370
                self.match(PythonParser.FROM)
                self.state = 1371
                self.expression()
                pass
            elif token in [4, 5, 8, 9, 10, 11, 13, 15, 17, 18, 19, 20, 26, 32, 53, 55, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97, 98]:
                self.state = 1373
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994879022880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                    self.state = 1372
                    self.star_expressions()


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

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_star_expressions

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




    def star_expressions(self):

        localctx = PythonParser.Star_expressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_star_expressions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1377
            self.star_expression()
            self.state = 1382
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,161,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1378
                    self.match(PythonParser.COMMA)
                    self.state = 1379
                    self.star_expression() 
                self.state = 1384
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,161,self._ctx)

            self.state = 1386
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1385
                self.match(PythonParser.COMMA)


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


    class Star_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(PythonParser.STAR, 0)

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_star_expression

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




    def star_expression(self):

        localctx = PythonParser.Star_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_star_expression)
        try:
            self.state = 1391
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1388
                self.match(PythonParser.STAR)
                self.state = 1389
                self.bitwise_or(0)
                pass
            elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1390
                self.expression()
                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_named_expressionsContext(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, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.Star_named_expressionContext)
            else:
                return self.getTypedRuleContext(PythonParser.Star_named_expressionContext,i)


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

        def getRuleIndex(self):
            return PythonParser.RULE_star_named_expressions

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




    def star_named_expressions(self):

        localctx = PythonParser.Star_named_expressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_star_named_expressions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1393
            self.star_named_expression()
            self.state = 1398
            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 = 1394
                    self.match(PythonParser.COMMA)
                    self.state = 1395
                    self.star_named_expression() 
                self.state = 1400
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,164,self._ctx)

            self.state = 1402
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1401
                self.match(PythonParser.COMMA)


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


    class 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(PythonParser.STAR, 0)

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_star_named_expression

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




    def star_named_expression(self):

        localctx = PythonParser.Star_named_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_star_named_expression)
        try:
            self.state = 1407
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1404
                self.match(PythonParser.STAR)
                self.state = 1405
                self.bitwise_or(0)
                pass
            elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1406
                self.named_expression()
                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 Assignment_expressionContext(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(PythonParser.NameContext,0)


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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_assignment_expression

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




    def assignment_expression(self):

        localctx = PythonParser.Assignment_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_assignment_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1409
            self.name()
            self.state = 1410
            self.match(PythonParser.COLONEQUAL)
            self.state = 1411
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Named_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def assignment_expression(self):
            return self.getTypedRuleContext(PythonParser.Assignment_expressionContext,0)


        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_named_expression

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




    def named_expression(self):

        localctx = PythonParser.Named_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_named_expression)
        try:
            self.state = 1415
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1413
                self.assignment_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1414
                self.expression()
                pass


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


    class DisjunctionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_disjunction

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




    def disjunction(self):

        localctx = PythonParser.DisjunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_disjunction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1417
            self.conjunction()
            self.state = 1422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==89:
                self.state = 1418
                self.match(PythonParser.OR)
                self.state = 1419
                self.conjunction()
                self.state = 1424
                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 ConjunctionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_conjunction

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




    def conjunction(self):

        localctx = PythonParser.ConjunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_conjunction)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1425
            self.inversion()
            self.state = 1430
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==71:
                self.state = 1426
                self.match(PythonParser.AND)
                self.state = 1427
                self.inversion()
                self.state = 1432
                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 InversionContext(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(PythonParser.NOT, 0)

        def inversion(self):
            return self.getTypedRuleContext(PythonParser.InversionContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_inversion

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




    def inversion(self):

        localctx = PythonParser.InversionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_inversion)
        try:
            self.state = 1436
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [84]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1433
                self.match(PythonParser.NOT)
                self.state = 1434
                self.inversion()
                pass
            elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1435
                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 bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


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


        def getRuleIndex(self):
            return PythonParser.RULE_comparison

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




    def comparison(self):

        localctx = PythonParser.ComparisonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_comparison)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1438
            self.bitwise_or(0)
            self.state = 1442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 24)) & ~0x3f) == 0 and ((1 << (_la - 24)) & 1152957788490563827) != 0):
                self.state = 1439
                self.compare_op_bitwise_or_pair()
                self.state = 1444
                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 Compare_op_bitwise_or_pairContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def eq_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Eq_bitwise_orContext,0)


        def noteq_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Noteq_bitwise_orContext,0)


        def lte_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Lte_bitwise_orContext,0)


        def lt_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Lt_bitwise_orContext,0)


        def gte_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Gte_bitwise_orContext,0)


        def gt_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Gt_bitwise_orContext,0)


        def notin_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Notin_bitwise_orContext,0)


        def in_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.In_bitwise_orContext,0)


        def isnot_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Isnot_bitwise_orContext,0)


        def is_bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Is_bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_compare_op_bitwise_or_pair

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




    def compare_op_bitwise_or_pair(self):

        localctx = PythonParser.Compare_op_bitwise_or_pairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_compare_op_bitwise_or_pair)
        try:
            self.state = 1455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,172,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1445
                self.eq_bitwise_or()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1446
                self.noteq_bitwise_or()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1447
                self.lte_bitwise_or()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1448
                self.lt_bitwise_or()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1449
                self.gte_bitwise_or()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1450
                self.gt_bitwise_or()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1451
                self.notin_bitwise_or()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1452
                self.in_bitwise_or()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1453
                self.isnot_bitwise_or()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1454
                self.is_bitwise_or()
                pass


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


    class Eq_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_eq_bitwise_or

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




    def eq_bitwise_or(self):

        localctx = PythonParser.Eq_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_eq_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1457
            self.match(PythonParser.EQEQUAL)
            self.state = 1458
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Noteq_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_noteq_bitwise_or

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




    def noteq_bitwise_or(self):

        localctx = PythonParser.Noteq_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_noteq_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1460
            self.match(PythonParser.NOTEQUAL)
            self.state = 1461
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lte_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lte_bitwise_or

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




    def lte_bitwise_or(self):

        localctx = PythonParser.Lte_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_lte_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1463
            self.match(PythonParser.LESSEQUAL)
            self.state = 1464
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lt_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lt_bitwise_or

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




    def lt_bitwise_or(self):

        localctx = PythonParser.Lt_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_lt_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1466
            self.match(PythonParser.LESS)
            self.state = 1467
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Gte_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_gte_bitwise_or

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




    def gte_bitwise_or(self):

        localctx = PythonParser.Gte_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_gte_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1469
            self.match(PythonParser.GREATEREQUAL)
            self.state = 1470
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Gt_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_gt_bitwise_or

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




    def gt_bitwise_or(self):

        localctx = PythonParser.Gt_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_gt_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1472
            self.match(PythonParser.GREATER)
            self.state = 1473
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Notin_bitwise_orContext(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(PythonParser.NOT, 0)

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_notin_bitwise_or

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




    def notin_bitwise_or(self):

        localctx = PythonParser.Notin_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_notin_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1475
            self.match(PythonParser.NOT)
            self.state = 1476
            self.match(PythonParser.IN)
            self.state = 1477
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class In_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_in_bitwise_or

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




    def in_bitwise_or(self):

        localctx = PythonParser.In_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_in_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1479
            self.match(PythonParser.IN)
            self.state = 1480
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Isnot_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_isnot_bitwise_or

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




    def isnot_bitwise_or(self):

        localctx = PythonParser.Isnot_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_isnot_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1482
            self.match(PythonParser.IS)
            self.state = 1483
            self.match(PythonParser.NOT)
            self.state = 1484
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Is_bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_is_bitwise_or

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




    def is_bitwise_or(self):

        localctx = PythonParser.Is_bitwise_orContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_is_bitwise_or)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1486
            self.match(PythonParser.IS)
            self.state = 1487
            self.bitwise_or(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Bitwise_orContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def bitwise_xor(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_xorContext,0)


        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_bitwise_or

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



    def bitwise_or(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Bitwise_orContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 256
        self.enterRecursionRule(localctx, 256, self.RULE_bitwise_or, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1490
            self.bitwise_xor(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1497
            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:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.Bitwise_orContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_bitwise_or)
                    self.state = 1492
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1493
                    self.match(PythonParser.VBAR)
                    self.state = 1494
                    self.bitwise_xor(0) 
                self.state = 1499
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,173,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 Bitwise_xorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def bitwise_and(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_andContext,0)


        def bitwise_xor(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_xorContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_bitwise_xor

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



    def bitwise_xor(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Bitwise_xorContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 258
        self.enterRecursionRule(localctx, 258, self.RULE_bitwise_xor, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1501
            self.bitwise_and(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1508
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,174,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.Bitwise_xorContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_bitwise_xor)
                    self.state = 1503
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1504
                    self.match(PythonParser.CIRCUMFLEX)
                    self.state = 1505
                    self.bitwise_and(0) 
                self.state = 1510
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,174,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 Bitwise_andContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def shift_expr(self):
            return self.getTypedRuleContext(PythonParser.Shift_exprContext,0)


        def bitwise_and(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_andContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_bitwise_and

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



    def bitwise_and(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Bitwise_andContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 260
        self.enterRecursionRule(localctx, 260, self.RULE_bitwise_and, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1512
            self.shift_expr(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1519
            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:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.Bitwise_andContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_bitwise_and)
                    self.state = 1514
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1515
                    self.match(PythonParser.AMPER)
                    self.state = 1516
                    self.shift_expr(0) 
                self.state = 1521
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,175,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 Shift_exprContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sum_(self):
            return self.getTypedRuleContext(PythonParser.SumContext,0)


        def shift_expr(self):
            return self.getTypedRuleContext(PythonParser.Shift_exprContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_shift_expr

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



    def shift_expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.Shift_exprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 262
        self.enterRecursionRule(localctx, 262, self.RULE_shift_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1523
            self.sum_(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1530
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,176,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.Shift_exprContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_shift_expr)
                    self.state = 1525
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1526
                    _la = self._input.LA(1)
                    if not(_la==34 or _la==35):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1527
                    self.sum_(0) 
                self.state = 1532
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,176,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 SumContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def term(self):
            return self.getTypedRuleContext(PythonParser.TermContext,0)


        def sum_(self):
            return self.getTypedRuleContext(PythonParser.SumContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_sum

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



    def sum_(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.SumContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 264
        self.enterRecursionRule(localctx, 264, self.RULE_sum, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1534
            self.term(0)
            self._ctx.stop = self._input.LT(-1)
            self.state = 1541
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,177,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.SumContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_sum)
                    self.state = 1536
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1537
                    _la = self._input.LA(1)
                    if not(_la==18 or _la==19):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1538
                    self.term(0) 
                self.state = 1543
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,177,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 TermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def factor(self):
            return self.getTypedRuleContext(PythonParser.FactorContext,0)


        def term(self):
            return self.getTypedRuleContext(PythonParser.TermContext,0)


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

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

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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_term

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



    def term(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.TermContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 266
        self.enterRecursionRule(localctx, 266, self.RULE_term, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1545
            self.factor()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1552
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,178,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.TermContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_term)
                    self.state = 1547
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1548
                    _la = self._input.LA(1)
                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 1407375020916736) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1549
                    self.factor() 
                self.state = 1554
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,178,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 FactorContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def factor(self):
            return self.getTypedRuleContext(PythonParser.FactorContext,0)


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

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

        def power(self):
            return self.getTypedRuleContext(PythonParser.PowerContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_factor

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




    def factor(self):

        localctx = PythonParser.FactorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_factor)
        try:
            self.state = 1562
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [18]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1555
                self.match(PythonParser.PLUS)
                self.state = 1556
                self.factor()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1557
                self.match(PythonParser.MINUS)
                self.state = 1558
                self.factor()
                pass
            elif token in [32]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1559
                self.match(PythonParser.TILDE)
                self.state = 1560
                self.factor()
                pass
            elif token in [5, 8, 9, 10, 53, 56, 57, 61, 66, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1561
                self.power()
                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 PowerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def await_primary(self):
            return self.getTypedRuleContext(PythonParser.Await_primaryContext,0)


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

        def factor(self):
            return self.getTypedRuleContext(PythonParser.FactorContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_power

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




    def power(self):

        localctx = PythonParser.PowerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_power)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1564
            self.await_primary()
            self.state = 1567
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 1565
                self.match(PythonParser.DOUBLESTAR)
                self.state = 1566
                self.factor()


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


    class Await_primaryContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def primary(self):
            return self.getTypedRuleContext(PythonParser.PrimaryContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_await_primary

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




    def await_primary(self):

        localctx = PythonParser.Await_primaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_await_primary)
        try:
            self.state = 1572
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [57]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1569
                self.match(PythonParser.AWAIT)
                self.state = 1570
                self.primary(0)
                pass
            elif token in [5, 8, 9, 10, 53, 56, 61, 66, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1571
                self.primary(0)
                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 PrimaryContext(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(PythonParser.AtomContext,0)


        def primary(self):
            return self.getTypedRuleContext(PythonParser.PrimaryContext,0)


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

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


        def genexp(self):
            return self.getTypedRuleContext(PythonParser.GenexpContext,0)


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

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

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

        def slices(self):
            return self.getTypedRuleContext(PythonParser.SlicesContext,0)


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_primary

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



    def primary(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.PrimaryContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 274
        self.enterRecursionRule(localctx, 274, self.RULE_primary, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1575
            self.atom()
            self._ctx.stop = self._input.LT(-1)
            self.state = 1594
            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:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.PrimaryContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_primary)
                    self.state = 1577
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 1590
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,183,self._ctx)
                    if la_ == 1:
                        self.state = 1578
                        self.match(PythonParser.DOT)
                        self.state = 1579
                        self.name()
                        pass

                    elif la_ == 2:
                        self.state = 1580
                        self.genexp()
                        pass

                    elif la_ == 3:
                        self.state = 1581
                        self.match(PythonParser.LPAR)
                        self.state = 1583
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531023063598499616) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                            self.state = 1582
                            self.arguments()


                        self.state = 1585
                        self.match(PythonParser.RPAR)
                        pass

                    elif la_ == 4:
                        self.state = 1586
                        self.match(PythonParser.LSQB)
                        self.state = 1587
                        self.slices()
                        self.state = 1588
                        self.match(PythonParser.RSQB)
                        pass

             
                self.state = 1596
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,184,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 SlicesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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


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

        def getRuleIndex(self):
            return PythonParser.RULE_slices

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




    def slices(self):

        localctx = PythonParser.SlicesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_slices)
        self._la = 0 # Token type
        try:
            self.state = 1615
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1597
                self.slice_()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1600
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [5, 8, 9, 10, 15, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                    self.state = 1598
                    self.slice_()
                    pass
                elif token in [20]:
                    self.state = 1599
                    self.starred_expression()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1609
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,187,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1602
                        self.match(PythonParser.COMMA)
                        self.state = 1605
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [5, 8, 9, 10, 15, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                            self.state = 1603
                            self.slice_()
                            pass
                        elif token in [20]:
                            self.state = 1604
                            self.starred_expression()
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 1611
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,187,self._ctx)

                self.state = 1613
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 1612
                    self.match(PythonParser.COMMA)


                pass


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


    class SliceContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_slice

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




    def slice_(self):

        localctx = PythonParser.SliceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_slice)
        self._la = 0 # Token type
        try:
            self.state = 1631
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1618
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994877974304) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                    self.state = 1617
                    self.expression()


                self.state = 1620
                self.match(PythonParser.COLON)
                self.state = 1622
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994877974304) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                    self.state = 1621
                    self.expression()


                self.state = 1628
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==15:
                    self.state = 1624
                    self.match(PythonParser.COLON)
                    self.state = 1626
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994877974304) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                        self.state = 1625
                        self.expression()




                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1630
                self.named_expression()
                pass


        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 name(self):
            return self.getTypedRuleContext(PythonParser.NameContext,0)


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

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

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

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


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

        def tuple_(self):
            return self.getTypedRuleContext(PythonParser.TupleContext,0)


        def group(self):
            return self.getTypedRuleContext(PythonParser.GroupContext,0)


        def genexp(self):
            return self.getTypedRuleContext(PythonParser.GenexpContext,0)


        def list_(self):
            return self.getTypedRuleContext(PythonParser.ListContext,0)


        def listcomp(self):
            return self.getTypedRuleContext(PythonParser.ListcompContext,0)


        def dict_(self):
            return self.getTypedRuleContext(PythonParser.DictContext,0)


        def set_(self):
            return self.getTypedRuleContext(PythonParser.SetContext,0)


        def dictcomp(self):
            return self.getTypedRuleContext(PythonParser.DictcompContext,0)


        def setcomp(self):
            return self.getTypedRuleContext(PythonParser.SetcompContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_atom

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




    def atom(self):

        localctx = PythonParser.AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_atom)
        try:
            self.state = 1655
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [91, 92, 93, 94, 95]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1633
                self.name()
                pass
            elif token in [66]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1634
                self.match(PythonParser.TRUE)
                pass
            elif token in [56]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1635
                self.match(PythonParser.FALSE)
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1636
                self.match(PythonParser.NONE)
                pass
            elif token in [5, 97]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1637
                self.strings()
                pass
            elif token in [96]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1638
                self.match(PythonParser.NUMBER)
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 7)
                self.state = 1642
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
                if la_ == 1:
                    self.state = 1639
                    self.tuple_()
                    pass

                elif la_ == 2:
                    self.state = 1640
                    self.group()
                    pass

                elif la_ == 3:
                    self.state = 1641
                    self.genexp()
                    pass


                pass
            elif token in [9]:
                self.enterOuterAlt(localctx, 8)
                self.state = 1646
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,196,self._ctx)
                if la_ == 1:
                    self.state = 1644
                    self.list_()
                    pass

                elif la_ == 2:
                    self.state = 1645
                    self.listcomp()
                    pass


                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 9)
                self.state = 1652
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
                if la_ == 1:
                    self.state = 1648
                    self.dict_()
                    pass

                elif la_ == 2:
                    self.state = 1649
                    self.set_()
                    pass

                elif la_ == 3:
                    self.state = 1650
                    self.dictcomp()
                    pass

                elif la_ == 4:
                    self.state = 1651
                    self.setcomp()
                    pass


                pass
            elif token in [53]:
                self.enterOuterAlt(localctx, 10)
                self.state = 1654
                self.match(PythonParser.ELLIPSIS)
                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 GroupContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_group

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




    def group(self):

        localctx = PythonParser.GroupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_group)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1657
            self.match(PythonParser.LPAR)
            self.state = 1660
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [90]:
                self.state = 1658
                self.yield_expr()
                pass
            elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.state = 1659
                self.named_expression()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1662
            self.match(PythonParser.RPAR)
        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(PythonParser.LAMBDA, 0)

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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def lambda_params(self):
            return self.getTypedRuleContext(PythonParser.Lambda_paramsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lambdef

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




    def lambdef(self):

        localctx = PythonParser.LambdefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_lambdef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1664
            self.match(PythonParser.LAMBDA)
            self.state = 1666
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==20 or _la==36 or ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                self.state = 1665
                self.lambda_params()


            self.state = 1668
            self.match(PythonParser.COLON)
            self.state = 1669
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lambda_paramsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambda_parameters(self):
            return self.getTypedRuleContext(PythonParser.Lambda_parametersContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lambda_params

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




    def lambda_params(self):

        localctx = PythonParser.Lambda_paramsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_lambda_params)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1671
            self.lambda_parameters()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lambda_parametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambda_slash_no_default(self):
            return self.getTypedRuleContext(PythonParser.Lambda_slash_no_defaultContext,0)


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


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


        def lambda_star_etc(self):
            return self.getTypedRuleContext(PythonParser.Lambda_star_etcContext,0)


        def lambda_slash_with_default(self):
            return self.getTypedRuleContext(PythonParser.Lambda_slash_with_defaultContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lambda_parameters

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




    def lambda_parameters(self):

        localctx = PythonParser.Lambda_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_lambda_parameters)
        self._la = 0 # Token type
        try:
            self.state = 1722
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,211,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1673
                self.lambda_slash_no_default()
                self.state = 1677
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,201,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1674
                        self.lambda_param_no_default() 
                    self.state = 1679
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,201,self._ctx)

                self.state = 1683
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 1680
                    self.lambda_param_with_default()
                    self.state = 1685
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1687
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 1686
                    self.lambda_star_etc()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1689
                self.lambda_slash_with_default()
                self.state = 1693
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 1690
                    self.lambda_param_with_default()
                    self.state = 1695
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1697
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 1696
                    self.lambda_star_etc()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1700 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1699
                        self.lambda_param_no_default()

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

                self.state = 1707
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 1704
                    self.lambda_param_with_default()
                    self.state = 1709
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1711
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 1710
                    self.lambda_star_etc()


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1714 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1713
                    self.lambda_param_with_default()
                    self.state = 1716 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                        break

                self.state = 1719
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==20 or _la==36:
                    self.state = 1718
                    self.lambda_star_etc()


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1721
                self.lambda_star_etc()
                pass


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


    class Lambda_slash_no_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_lambda_slash_no_default

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




    def lambda_slash_no_default(self):

        localctx = PythonParser.Lambda_slash_no_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_lambda_slash_no_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1725 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1724
                self.lambda_param_no_default()
                self.state = 1727 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                    break

            self.state = 1729
            self.match(PythonParser.SLASH)
            self.state = 1731
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1730
                self.match(PythonParser.COMMA)


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


    class Lambda_slash_with_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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


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

        def getRuleIndex(self):
            return PythonParser.RULE_lambda_slash_with_default

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




    def lambda_slash_with_default(self):

        localctx = PythonParser.Lambda_slash_with_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_lambda_slash_with_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1736
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,214,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1733
                    self.lambda_param_no_default() 
                self.state = 1738
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,214,self._ctx)

            self.state = 1740 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1739
                self.lambda_param_with_default()
                self.state = 1742 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                    break

            self.state = 1744
            self.match(PythonParser.SLASH)
            self.state = 1746
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1745
                self.match(PythonParser.COMMA)


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


    class Lambda_star_etcContext(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(PythonParser.STAR, 0)

        def lambda_param_no_default(self):
            return self.getTypedRuleContext(PythonParser.Lambda_param_no_defaultContext,0)


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


        def lambda_kwds(self):
            return self.getTypedRuleContext(PythonParser.Lambda_kwdsContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_lambda_star_etc

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




    def lambda_star_etc(self):

        localctx = PythonParser.Lambda_star_etcContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_lambda_star_etc)
        self._la = 0 # Token type
        try:
            self.state = 1770
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,221,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1748
                self.match(PythonParser.STAR)
                self.state = 1749
                self.lambda_param_no_default()
                self.state = 1753
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while ((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0):
                    self.state = 1750
                    self.lambda_param_maybe_default()
                    self.state = 1755
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1757
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==36:
                    self.state = 1756
                    self.lambda_kwds()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1759
                self.match(PythonParser.STAR)
                self.state = 1760
                self.match(PythonParser.COMMA)
                self.state = 1762 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1761
                    self.lambda_param_maybe_default()
                    self.state = 1764 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 31) != 0)):
                        break

                self.state = 1767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==36:
                    self.state = 1766
                    self.lambda_kwds()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1769
                self.lambda_kwds()
                pass


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


    class Lambda_kwdsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def lambda_param_no_default(self):
            return self.getTypedRuleContext(PythonParser.Lambda_param_no_defaultContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lambda_kwds

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




    def lambda_kwds(self):

        localctx = PythonParser.Lambda_kwdsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_lambda_kwds)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1772
            self.match(PythonParser.DOUBLESTAR)
            self.state = 1773
            self.lambda_param_no_default()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Lambda_param_no_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambda_param(self):
            return self.getTypedRuleContext(PythonParser.Lambda_paramContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_lambda_param_no_default

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




    def lambda_param_no_default(self):

        localctx = PythonParser.Lambda_param_no_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_lambda_param_no_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1775
            self.lambda_param()
            self.state = 1777
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1776
                self.match(PythonParser.COMMA)


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


    class Lambda_param_with_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambda_param(self):
            return self.getTypedRuleContext(PythonParser.Lambda_paramContext,0)


        def default_assignment(self):
            return self.getTypedRuleContext(PythonParser.Default_assignmentContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_lambda_param_with_default

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




    def lambda_param_with_default(self):

        localctx = PythonParser.Lambda_param_with_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_lambda_param_with_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1779
            self.lambda_param()
            self.state = 1780
            self.default_assignment()
            self.state = 1782
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1781
                self.match(PythonParser.COMMA)


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


    class Lambda_param_maybe_defaultContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambda_param(self):
            return self.getTypedRuleContext(PythonParser.Lambda_paramContext,0)


        def default_assignment(self):
            return self.getTypedRuleContext(PythonParser.Default_assignmentContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_lambda_param_maybe_default

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




    def lambda_param_maybe_default(self):

        localctx = PythonParser.Lambda_param_maybe_defaultContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_lambda_param_maybe_default)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1784
            self.lambda_param()
            self.state = 1786
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26:
                self.state = 1785
                self.default_assignment()


            self.state = 1789
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1788
                self.match(PythonParser.COMMA)


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


    class Lambda_paramContext(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(PythonParser.NameContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_lambda_param

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




    def lambda_param(self):

        localctx = PythonParser.Lambda_paramContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_lambda_param)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1791
            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 Fstring_middleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def fstring_replacement_field(self):
            return self.getTypedRuleContext(PythonParser.Fstring_replacement_fieldContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_fstring_middle

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




    def fstring_middle(self):

        localctx = PythonParser.Fstring_middleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_fstring_middle)
        try:
            self.state = 1795
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [10]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1793
                self.fstring_replacement_field()
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1794
                self.match(PythonParser.FSTRING_MIDDLE)
                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 Fstring_replacement_fieldContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def annotated_rhs(self):
            return self.getTypedRuleContext(PythonParser.Annotated_rhsContext,0)


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

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

        def fstring_conversion(self):
            return self.getTypedRuleContext(PythonParser.Fstring_conversionContext,0)


        def fstring_full_format_spec(self):
            return self.getTypedRuleContext(PythonParser.Fstring_full_format_specContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_fstring_replacement_field

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




    def fstring_replacement_field(self):

        localctx = PythonParser.Fstring_replacement_fieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_fstring_replacement_field)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1797
            self.match(PythonParser.LBRACE)
            self.state = 1798
            self.annotated_rhs()
            self.state = 1800
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==26:
                self.state = 1799
                self.match(PythonParser.EQUAL)


            self.state = 1803
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==55:
                self.state = 1802
                self.fstring_conversion()


            self.state = 1806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==15:
                self.state = 1805
                self.fstring_full_format_spec()


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


    class Fstring_conversionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_fstring_conversion

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




    def fstring_conversion(self):

        localctx = PythonParser.Fstring_conversionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_fstring_conversion)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1810
            self.match(PythonParser.EXCLAMATION)
            self.state = 1811
            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 Fstring_full_format_specContext(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(PythonParser.COLON, 0)

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


        def getRuleIndex(self):
            return PythonParser.RULE_fstring_full_format_spec

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




    def fstring_full_format_spec(self):

        localctx = PythonParser.Fstring_full_format_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_fstring_full_format_spec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1813
            self.match(PythonParser.COLON)
            self.state = 1817
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==6 or _la==10:
                self.state = 1814
                self.fstring_format_spec()
                self.state = 1819
                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 Fstring_format_specContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def fstring_replacement_field(self):
            return self.getTypedRuleContext(PythonParser.Fstring_replacement_fieldContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_fstring_format_spec

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




    def fstring_format_spec(self):

        localctx = PythonParser.Fstring_format_specContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_fstring_format_spec)
        try:
            self.state = 1822
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [6]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1820
                self.match(PythonParser.FSTRING_MIDDLE)
                pass
            elif token in [10]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1821
                self.fstring_replacement_field()
                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 FstringContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_fstring

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




    def fstring(self):

        localctx = PythonParser.FstringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_fstring)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1824
            self.match(PythonParser.FSTRING_START)
            self.state = 1828
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==6 or _la==10:
                self.state = 1825
                self.fstring_middle()
                self.state = 1830
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class StringContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_string

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




    def string(self):

        localctx = PythonParser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_string)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1833
            self.match(PythonParser.STRING)
        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 fstring(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(PythonParser.FstringContext)
            else:
                return self.getTypedRuleContext(PythonParser.FstringContext,i)


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


        def getRuleIndex(self):
            return PythonParser.RULE_strings

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




    def strings(self):

        localctx = PythonParser.StringsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_strings)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1837 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1837
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [5]:
                        self.state = 1835
                        self.fstring()
                        pass
                    elif token in [97]:
                        self.state = 1836
                        self.string()
                        pass
                    else:
                        raise NoViableAltException(self)


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

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

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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_list

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




    def list_(self):

        localctx = PythonParser.ListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1841
            self.match(PythonParser.LSQB)
            self.state = 1843
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994879022880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 1842
                self.star_named_expressions()


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


    class TupleContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_tuple

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




    def tuple_(self):

        localctx = PythonParser.TupleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_tuple)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1847
            self.match(PythonParser.LPAR)
            self.state = 1853
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994879022880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 1848
                self.star_named_expression()
                self.state = 1849
                self.match(PythonParser.COMMA)
                self.state = 1851
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531022994879022880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                    self.state = 1850
                    self.star_named_expressions()




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


    class SetContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_set

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




    def set_(self):

        localctx = PythonParser.SetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_set)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1857
            self.match(PythonParser.LBRACE)
            self.state = 1858
            self.star_named_expressions()
            self.state = 1859
            self.match(PythonParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def double_starred_kvpairs(self):
            return self.getTypedRuleContext(PythonParser.Double_starred_kvpairsContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_dict

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




    def dict_(self):

        localctx = PythonParser.DictContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_dict)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1861
            self.match(PythonParser.LBRACE)
            self.state = 1863
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531023063597451040) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                self.state = 1862
                self.double_starred_kvpairs()


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


    class Double_starred_kvpairsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_double_starred_kvpairs

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




    def double_starred_kvpairs(self):

        localctx = PythonParser.Double_starred_kvpairsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_double_starred_kvpairs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1867
            self.double_starred_kvpair()
            self.state = 1872
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,239,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1868
                    self.match(PythonParser.COMMA)
                    self.state = 1869
                    self.double_starred_kvpair() 
                self.state = 1874
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,239,self._ctx)

            self.state = 1876
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1875
                self.match(PythonParser.COMMA)


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


    class Double_starred_kvpairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def bitwise_or(self):
            return self.getTypedRuleContext(PythonParser.Bitwise_orContext,0)


        def kvpair(self):
            return self.getTypedRuleContext(PythonParser.KvpairContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_double_starred_kvpair

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




    def double_starred_kvpair(self):

        localctx = PythonParser.Double_starred_kvpairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_double_starred_kvpair)
        try:
            self.state = 1881
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [36]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1878
                self.match(PythonParser.DOUBLESTAR)
                self.state = 1879
                self.bitwise_or(0)
                pass
            elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1880
                self.kvpair()
                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 KvpairContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_kvpair

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




    def kvpair(self):

        localctx = PythonParser.KvpairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_kvpair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1883
            self.expression()
            self.state = 1884
            self.match(PythonParser.COLON)
            self.state = 1885
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class For_if_clausesContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_for_if_clauses

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




    def for_if_clauses(self):

        localctx = PythonParser.For_if_clausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_for_if_clauses)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1888 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1887
                self.for_if_clause()
                self.state = 1890 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==73 or _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 For_if_clauseContext(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(PythonParser.FOR, 0)

        def star_targets(self):
            return self.getTypedRuleContext(PythonParser.Star_targetsContext,0)


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

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


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_for_if_clause

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




    def for_if_clause(self):

        localctx = PythonParser.For_if_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_for_if_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1893
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==86:
                self.state = 1892
                self.match(PythonParser.ASYNC)


            self.state = 1895
            self.match(PythonParser.FOR)
            self.state = 1896
            self.star_targets()
            self.state = 1897
            self.match(PythonParser.IN)
            self.state = 1898
            self.disjunction()
            self.state = 1903
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==88:
                self.state = 1899
                self.match(PythonParser.IF)
                self.state = 1900
                self.disjunction()
                self.state = 1905
                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 ListcompContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def for_if_clauses(self):
            return self.getTypedRuleContext(PythonParser.For_if_clausesContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_listcomp

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




    def listcomp(self):

        localctx = PythonParser.ListcompContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_listcomp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1906
            self.match(PythonParser.LSQB)
            self.state = 1907
            self.named_expression()
            self.state = 1908
            self.for_if_clauses()
            self.state = 1909
            self.match(PythonParser.RSQB)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SetcompContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def named_expression(self):
            return self.getTypedRuleContext(PythonParser.Named_expressionContext,0)


        def for_if_clauses(self):
            return self.getTypedRuleContext(PythonParser.For_if_clausesContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_setcomp

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




    def setcomp(self):

        localctx = PythonParser.SetcompContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_setcomp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1911
            self.match(PythonParser.LBRACE)
            self.state = 1912
            self.named_expression()
            self.state = 1913
            self.for_if_clauses()
            self.state = 1914
            self.match(PythonParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class GenexpContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def for_if_clauses(self):
            return self.getTypedRuleContext(PythonParser.For_if_clausesContext,0)


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

        def assignment_expression(self):
            return self.getTypedRuleContext(PythonParser.Assignment_expressionContext,0)


        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_genexp

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




    def genexp(self):

        localctx = PythonParser.GenexpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_genexp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1916
            self.match(PythonParser.LPAR)
            self.state = 1919
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,245,self._ctx)
            if la_ == 1:
                self.state = 1917
                self.assignment_expression()
                pass

            elif la_ == 2:
                self.state = 1918
                self.expression()
                pass


            self.state = 1921
            self.for_if_clauses()
            self.state = 1922
            self.match(PythonParser.RPAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DictcompContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def kvpair(self):
            return self.getTypedRuleContext(PythonParser.KvpairContext,0)


        def for_if_clauses(self):
            return self.getTypedRuleContext(PythonParser.For_if_clausesContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_dictcomp

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




    def dictcomp(self):

        localctx = PythonParser.DictcompContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_dictcomp)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1924
            self.match(PythonParser.LBRACE)
            self.state = 1925
            self.kvpair()
            self.state = 1926
            self.for_if_clauses()
            self.state = 1927
            self.match(PythonParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgumentsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_arguments

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




    def arguments(self):

        localctx = PythonParser.ArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_arguments)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1929
            self.args()
            self.state = 1931
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 1930
                self.match(PythonParser.COMMA)


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


    class ArgsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


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


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


        def getRuleIndex(self):
            return PythonParser.RULE_args

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




    def args(self):

        localctx = PythonParser.ArgsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_args)
        try:
            self.state = 1958
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,253,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1938
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [20]:
                    self.state = 1933
                    self.starred_expression()
                    pass
                elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                    self.state = 1936
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,247,self._ctx)
                    if la_ == 1:
                        self.state = 1934
                        self.assignment_expression()
                        pass

                    elif la_ == 2:
                        self.state = 1935
                        self.expression()
                        pass


                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1950
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,251,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1940
                        self.match(PythonParser.COMMA)
                        self.state = 1946
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [20]:
                            self.state = 1941
                            self.starred_expression()
                            pass
                        elif token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                            self.state = 1944
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,249,self._ctx)
                            if la_ == 1:
                                self.state = 1942
                                self.assignment_expression()
                                pass

                            elif la_ == 2:
                                self.state = 1943
                                self.expression()
                                pass


                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 1952
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,251,self._ctx)

                self.state = 1955
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
                if la_ == 1:
                    self.state = 1953
                    self.match(PythonParser.COMMA)
                    self.state = 1954
                    self.kwargs()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1957
                self.kwargs()
                pass


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


    class KwargsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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


        def getRuleIndex(self):
            return PythonParser.RULE_kwargs

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




    def kwargs(self):

        localctx = PythonParser.KwargsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_kwargs)
        try:
            self.state = 1987
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,258,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1960
                self.kwarg_or_starred()
                self.state = 1965
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,254,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1961
                        self.match(PythonParser.COMMA)
                        self.state = 1962
                        self.kwarg_or_starred() 
                    self.state = 1967
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,254,self._ctx)

                self.state = 1977
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
                if la_ == 1:
                    self.state = 1968
                    self.match(PythonParser.COMMA)
                    self.state = 1969
                    self.kwarg_or_double_starred()
                    self.state = 1974
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,255,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 1970
                            self.match(PythonParser.COMMA)
                            self.state = 1971
                            self.kwarg_or_double_starred() 
                        self.state = 1976
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,255,self._ctx)



                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1979
                self.kwarg_or_double_starred()
                self.state = 1984
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,257,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1980
                        self.match(PythonParser.COMMA)
                        self.state = 1981
                        self.kwarg_or_double_starred() 
                    self.state = 1986
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,257,self._ctx)

                pass


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


    class Starred_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(PythonParser.STAR, 0)

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_starred_expression

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




    def starred_expression(self):

        localctx = PythonParser.Starred_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_starred_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1989
            self.match(PythonParser.STAR)
            self.state = 1990
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Kwarg_or_starredContext(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(PythonParser.NameContext,0)


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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


        def starred_expression(self):
            return self.getTypedRuleContext(PythonParser.Starred_expressionContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_kwarg_or_starred

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




    def kwarg_or_starred(self):

        localctx = PythonParser.Kwarg_or_starredContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_kwarg_or_starred)
        try:
            self.state = 1997
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [91, 92, 93, 94, 95]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1992
                self.name()
                self.state = 1993
                self.match(PythonParser.EQUAL)
                self.state = 1994
                self.expression()
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1996
                self.starred_expression()
                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 Kwarg_or_double_starredContext(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(PythonParser.NameContext,0)


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

        def expression(self):
            return self.getTypedRuleContext(PythonParser.ExpressionContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_kwarg_or_double_starred

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




    def kwarg_or_double_starred(self):

        localctx = PythonParser.Kwarg_or_double_starredContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_kwarg_or_double_starred)
        try:
            self.state = 2005
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [91, 92, 93, 94, 95]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1999
                self.name()
                self.state = 2000
                self.match(PythonParser.EQUAL)
                self.state = 2001
                self.expression()
                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2003
                self.match(PythonParser.DOUBLESTAR)
                self.state = 2004
                self.expression()
                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_targetsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_star_targets

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




    def star_targets(self):

        localctx = PythonParser.Star_targetsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_star_targets)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2007
            self.star_target()
            self.state = 2012
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,261,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2008
                    self.match(PythonParser.COMMA)
                    self.state = 2009
                    self.star_target() 
                self.state = 2014
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,261,self._ctx)

            self.state = 2016
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 2015
                self.match(PythonParser.COMMA)


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


    class Star_targets_list_seqContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_star_targets_list_seq

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




    def star_targets_list_seq(self):

        localctx = PythonParser.Star_targets_list_seqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_star_targets_list_seq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2018
            self.star_target()
            self.state = 2023
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,263,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2019
                    self.match(PythonParser.COMMA)
                    self.state = 2020
                    self.star_target() 
                self.state = 2025
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,263,self._ctx)

            self.state = 2027
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 2026
                self.match(PythonParser.COMMA)


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


    class Star_targets_tuple_seqContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_star_targets_tuple_seq

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




    def star_targets_tuple_seq(self):

        localctx = PythonParser.Star_targets_tuple_seqContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_star_targets_tuple_seq)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2029
            self.star_target()
            self.state = 2040
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,267,self._ctx)
            if la_ == 1:
                self.state = 2030
                self.match(PythonParser.COMMA)
                pass

            elif la_ == 2:
                self.state = 2033 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 2031
                        self.match(PythonParser.COMMA)
                        self.state = 2032
                        self.star_target()

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

                self.state = 2038
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 2037
                    self.match(PythonParser.COMMA)


                pass


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


    class Star_targetContext(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(PythonParser.STAR, 0)

        def star_target(self):
            return self.getTypedRuleContext(PythonParser.Star_targetContext,0)


        def target_with_star_atom(self):
            return self.getTypedRuleContext(PythonParser.Target_with_star_atomContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_star_target

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




    def star_target(self):

        localctx = PythonParser.Star_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_star_target)
        try:
            self.state = 2045
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [20]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2042
                self.match(PythonParser.STAR)

                self.state = 2043
                self.star_target()
                pass
            elif token in [5, 8, 9, 10, 53, 56, 61, 66, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2044
                self.target_with_star_atom()
                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 Target_with_star_atomContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def t_primary(self):
            return self.getTypedRuleContext(PythonParser.T_primaryContext,0)


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

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


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

        def slices(self):
            return self.getTypedRuleContext(PythonParser.SlicesContext,0)


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

        def star_atom(self):
            return self.getTypedRuleContext(PythonParser.Star_atomContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_target_with_star_atom

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




    def target_with_star_atom(self):

        localctx = PythonParser.Target_with_star_atomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_target_with_star_atom)
        try:
            self.state = 2057
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2047
                self.t_primary(0)
                self.state = 2054
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [14]:
                    self.state = 2048
                    self.match(PythonParser.DOT)
                    self.state = 2049
                    self.name()
                    pass
                elif token in [9]:
                    self.state = 2050
                    self.match(PythonParser.LSQB)
                    self.state = 2051
                    self.slices()
                    self.state = 2052
                    self.match(PythonParser.RSQB)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2056
                self.star_atom()
                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_atomContext(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(PythonParser.NameContext,0)


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

        def target_with_star_atom(self):
            return self.getTypedRuleContext(PythonParser.Target_with_star_atomContext,0)


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

        def star_targets_tuple_seq(self):
            return self.getTypedRuleContext(PythonParser.Star_targets_tuple_seqContext,0)


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

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

        def star_targets_list_seq(self):
            return self.getTypedRuleContext(PythonParser.Star_targets_list_seqContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_star_atom

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




    def star_atom(self):

        localctx = PythonParser.Star_atomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_star_atom)
        self._la = 0 # Token type
        try:
            self.state = 2074
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2059
                self.name()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2060
                self.match(PythonParser.LPAR)
                self.state = 2061
                self.target_with_star_atom()
                self.state = 2062
                self.match(PythonParser.RPAR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2064
                self.match(PythonParser.LPAR)
                self.state = 2066
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2386907802507413280) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                    self.state = 2065
                    self.star_targets_tuple_seq()


                self.state = 2068
                self.match(PythonParser.RPAR)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2069
                self.match(PythonParser.LSQB)
                self.state = 2071
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2386907802507413280) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                    self.state = 2070
                    self.star_targets_list_seq()


                self.state = 2073
                self.match(PythonParser.RSQB)
                pass


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


    class Single_targetContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def single_subscript_attribute_target(self):
            return self.getTypedRuleContext(PythonParser.Single_subscript_attribute_targetContext,0)


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


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

        def single_target(self):
            return self.getTypedRuleContext(PythonParser.Single_targetContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_single_target

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




    def single_target(self):

        localctx = PythonParser.Single_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_single_target)
        try:
            self.state = 2082
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2076
                self.single_subscript_attribute_target()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2078
                self.match(PythonParser.LPAR)
                self.state = 2079
                self.single_target()
                self.state = 2080
                self.match(PythonParser.RPAR)
                pass


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


    class Single_subscript_attribute_targetContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def t_primary(self):
            return self.getTypedRuleContext(PythonParser.T_primaryContext,0)


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

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


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

        def slices(self):
            return self.getTypedRuleContext(PythonParser.SlicesContext,0)


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

        def getRuleIndex(self):
            return PythonParser.RULE_single_subscript_attribute_target

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




    def single_subscript_attribute_target(self):

        localctx = PythonParser.Single_subscript_attribute_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_single_subscript_attribute_target)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2084
            self.t_primary(0)
            self.state = 2091
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [14]:
                self.state = 2085
                self.match(PythonParser.DOT)
                self.state = 2086
                self.name()
                pass
            elif token in [9]:
                self.state = 2087
                self.match(PythonParser.LSQB)
                self.state = 2088
                self.slices()
                self.state = 2089
                self.match(PythonParser.RSQB)
                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 T_primaryContext(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(PythonParser.AtomContext,0)


        def t_primary(self):
            return self.getTypedRuleContext(PythonParser.T_primaryContext,0)


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

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


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

        def slices(self):
            return self.getTypedRuleContext(PythonParser.SlicesContext,0)


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

        def genexp(self):
            return self.getTypedRuleContext(PythonParser.GenexpContext,0)


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

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

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


        def getRuleIndex(self):
            return PythonParser.RULE_t_primary

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



    def t_primary(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = PythonParser.T_primaryContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 376
        self.enterRecursionRule(localctx, 376, self.RULE_t_primary, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2094
            self.atom()
            self._ctx.stop = self._input.LT(-1)
            self.state = 2113
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,278,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = PythonParser.T_primaryContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_t_primary)
                    self.state = 2096
                    if not self.precpred(self._ctx, 2):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                    self.state = 2109
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,277,self._ctx)
                    if la_ == 1:
                        self.state = 2097
                        self.match(PythonParser.DOT)
                        self.state = 2098
                        self.name()
                        pass

                    elif la_ == 2:
                        self.state = 2099
                        self.match(PythonParser.LSQB)
                        self.state = 2100
                        self.slices()
                        self.state = 2101
                        self.match(PythonParser.RSQB)
                        pass

                    elif la_ == 3:
                        self.state = 2103
                        self.genexp()
                        pass

                    elif la_ == 4:
                        self.state = 2104
                        self.match(PythonParser.LPAR)
                        self.state = 2106
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2531023063598499616) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261675265) != 0):
                            self.state = 2105
                            self.arguments()


                        self.state = 2108
                        self.match(PythonParser.RPAR)
                        pass

             
                self.state = 2115
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,278,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 Del_targetsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return PythonParser.RULE_del_targets

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




    def del_targets(self):

        localctx = PythonParser.Del_targetsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_del_targets)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2116
            self.del_target()
            self.state = 2121
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,279,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2117
                    self.match(PythonParser.COMMA)
                    self.state = 2118
                    self.del_target() 
                self.state = 2123
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,279,self._ctx)

            self.state = 2125
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 2124
                self.match(PythonParser.COMMA)


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


    class Del_targetContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def t_primary(self):
            return self.getTypedRuleContext(PythonParser.T_primaryContext,0)


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

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


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

        def slices(self):
            return self.getTypedRuleContext(PythonParser.SlicesContext,0)


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

        def del_t_atom(self):
            return self.getTypedRuleContext(PythonParser.Del_t_atomContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_del_target

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




    def del_target(self):

        localctx = PythonParser.Del_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_del_target)
        try:
            self.state = 2137
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,282,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2127
                self.t_primary(0)
                self.state = 2134
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [14]:
                    self.state = 2128
                    self.match(PythonParser.DOT)
                    self.state = 2129
                    self.name()
                    pass
                elif token in [9]:
                    self.state = 2130
                    self.match(PythonParser.LSQB)
                    self.state = 2131
                    self.slices()
                    self.state = 2132
                    self.match(PythonParser.RSQB)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2136
                self.del_t_atom()
                pass


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


    class Del_t_atomContext(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(PythonParser.NameContext,0)


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

        def del_target(self):
            return self.getTypedRuleContext(PythonParser.Del_targetContext,0)


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

        def del_targets(self):
            return self.getTypedRuleContext(PythonParser.Del_targetsContext,0)


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

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

        def getRuleIndex(self):
            return PythonParser.RULE_del_t_atom

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




    def del_t_atom(self):

        localctx = PythonParser.Del_t_atomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_del_t_atom)
        self._la = 0 # Token type
        try:
            self.state = 2154
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,285,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2139
                self.name()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2140
                self.match(PythonParser.LPAR)
                self.state = 2141
                self.del_target()
                self.state = 2142
                self.match(PythonParser.RPAR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 2144
                self.match(PythonParser.LPAR)
                self.state = 2146
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2386907802506364704) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                    self.state = 2145
                    self.del_targets()


                self.state = 2148
                self.match(PythonParser.RPAR)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 2149
                self.match(PythonParser.LSQB)
                self.state = 2151
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2386907802506364704) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 4261412865) != 0):
                    self.state = 2150
                    self.del_targets()


                self.state = 2153
                self.match(PythonParser.RSQB)
                pass


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


    class Type_expressionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

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

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

        def getRuleIndex(self):
            return PythonParser.RULE_type_expressions

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




    def type_expressions(self):

        localctx = PythonParser.Type_expressionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_type_expressions)
        self._la = 0 # Token type
        try:
            self.state = 2187
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5, 8, 9, 10, 18, 19, 32, 53, 56, 57, 61, 66, 74, 84, 91, 92, 93, 94, 95, 96, 97]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2156
                self.expression()
                self.state = 2161
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,286,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2157
                        self.match(PythonParser.COMMA)
                        self.state = 2158
                        self.expression() 
                    self.state = 2163
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,286,self._ctx)

                self.state = 2176
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 2164
                    self.match(PythonParser.COMMA)
                    self.state = 2174
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [20]:
                        self.state = 2165
                        self.match(PythonParser.STAR)
                        self.state = 2166
                        self.expression()
                        self.state = 2170
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==16:
                            self.state = 2167
                            self.match(PythonParser.COMMA)
                            self.state = 2168
                            self.match(PythonParser.DOUBLESTAR)
                            self.state = 2169
                            self.expression()


                        pass
                    elif token in [36]:
                        self.state = 2172
                        self.match(PythonParser.DOUBLESTAR)
                        self.state = 2173
                        self.expression()
                        pass
                    else:
                        raise NoViableAltException(self)



                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2178
                self.match(PythonParser.STAR)
                self.state = 2179
                self.expression()
                self.state = 2183
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==16:
                    self.state = 2180
                    self.match(PythonParser.COMMA)
                    self.state = 2181
                    self.match(PythonParser.DOUBLESTAR)
                    self.state = 2182
                    self.expression()


                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2185
                self.match(PythonParser.DOUBLESTAR)
                self.state = 2186
                self.expression()
                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 Func_type_commentContext(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(PythonParser.NEWLINE, 0)

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

        def getRuleIndex(self):
            return PythonParser.RULE_func_type_comment

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




    def func_type_comment(self):

        localctx = PythonParser.Func_type_commentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_func_type_comment)
        try:
            self.state = 2192
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [98]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2189
                self.match(PythonParser.NEWLINE)
                self.state = 2190
                self.match(PythonParser.TYPE_COMMENT)
                pass
            elif token in [4]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2191
                self.match(PythonParser.TYPE_COMMENT)
                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 Name_except_underscoreContext(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(PythonParser.NAME, 0)

        def NAME_OR_TYPE(self):
            return self.getToken(PythonParser.NAME_OR_TYPE, 0)

        def NAME_OR_MATCH(self):
            return self.getToken(PythonParser.NAME_OR_MATCH, 0)

        def NAME_OR_CASE(self):
            return self.getToken(PythonParser.NAME_OR_CASE, 0)

        def getRuleIndex(self):
            return PythonParser.RULE_name_except_underscore

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitName_except_underscore" ):
                return visitor.visitName_except_underscore(self)
            else:
                return visitor.visitChildren(self)




    def name_except_underscore(self):

        localctx = PythonParser.Name_except_underscoreContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_name_except_underscore)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2194
            _la = self._input.LA(1)
            if not(((((_la - 91)) & ~0x3f) == 0 and ((1 << (_la - 91)) & 23) != 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 NameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NAME_OR_WILDCARD(self):
            return self.getToken(PythonParser.NAME_OR_WILDCARD, 0)

        def name_except_underscore(self):
            return self.getTypedRuleContext(PythonParser.Name_except_underscoreContext,0)


        def getRuleIndex(self):
            return PythonParser.RULE_name

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitName" ):
                return visitor.visitName(self)
            else:
                return visitor.visitChildren(self)




    def name(self):

        localctx = PythonParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_name)
        try:
            self.state = 2198
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [94]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2196
                self.match(PythonParser.NAME_OR_WILDCARD)
                pass
            elif token in [91, 92, 93, 95]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2197
                self.name_except_underscore()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[28] = self.dotted_name_sempred
        self._predicates[128] = self.bitwise_or_sempred
        self._predicates[129] = self.bitwise_xor_sempred
        self._predicates[130] = self.bitwise_and_sempred
        self._predicates[131] = self.shift_expr_sempred
        self._predicates[132] = self.sum_sempred
        self._predicates[133] = self.term_sempred
        self._predicates[137] = self.primary_sempred
        self._predicates[188] = self.t_primary_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 dotted_name_sempred(self, localctx:Dotted_nameContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 2)
         

    def bitwise_or_sempred(self, localctx:Bitwise_orContext, predIndex:int):
            if predIndex == 1:
                return self.precpred(self._ctx, 2)
         

    def bitwise_xor_sempred(self, localctx:Bitwise_xorContext, predIndex:int):
            if predIndex == 2:
                return self.precpred(self._ctx, 2)
         

    def bitwise_and_sempred(self, localctx:Bitwise_andContext, predIndex:int):
            if predIndex == 3:
                return self.precpred(self._ctx, 2)
         

    def shift_expr_sempred(self, localctx:Shift_exprContext, predIndex:int):
            if predIndex == 4:
                return self.precpred(self._ctx, 2)
         

    def sum_sempred(self, localctx:SumContext, predIndex:int):
            if predIndex == 5:
                return self.precpred(self._ctx, 2)
         

    def term_sempred(self, localctx:TermContext, predIndex:int):
            if predIndex == 6:
                return self.precpred(self._ctx, 2)
         

    def primary_sempred(self, localctx:PrimaryContext, predIndex:int):
            if predIndex == 7:
                return self.precpred(self._ctx, 2)
         

    def t_primary_sempred(self, localctx:T_primaryContext, predIndex:int):
            if predIndex == 8:
                return self.precpred(self._ctx, 2)
         




