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

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

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

class CSharpParser ( CSharpParserBase ):

    grammarFileName = "CSharpParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'\\u00EF\\u00BB\\u00BF'", "<INVALID>", 
                     "'/***/'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", 
                     "'as'", "'ascending'", "'async'", "'await'", "'base'", 
                     "'bool'", "'break'", "'by'", "'byte'", "'case'", "'catch'", 
                     "'char'", "'checked'", "'class'", "'const'", "'continue'", 
                     "'decimal'", "'default'", "'delegate'", "'descending'", 
                     "'do'", "'double'", "'dynamic'", "'else'", "'enum'", 
                     "'equals'", "'event'", "'explicit'", "'extern'", "'false'", 
                     "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", 
                     "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", 
                     "'in'", "'int'", "'interface'", "'internal'", "'into'", 
                     "'is'", "'join'", "'let'", "'lock'", "'long'", "'nameof'", 
                     "'namespace'", "'new'", "'null'", "'object'", "'on'", 
                     "'operator'", "'orderby'", "'out'", "'override'", "'params'", 
                     "'partial'", "'private'", "'protected'", "'public'", 
                     "'readonly'", "'ref'", "'remove'", "'return'", "'sbyte'", 
                     "'sealed'", "'select'", "'set'", "'short'", "'sizeof'", 
                     "'stackalloc'", "'static'", "'string'", "'struct'", 
                     "'switch'", "'this'", "'throw'", "'true'", "'try'", 
                     "'typeof'", "'uint'", "'ulong'", "'unchecked'", "'unmanaged'", 
                     "'unsafe'", "'ushort'", "'using'", "'var'", "'virtual'", 
                     "'void'", "'volatile'", "'when'", "'where'", "'while'", 
                     "'yield'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'{'", "'}'", 
                     "'['", "']'", "'('", "')'", "'.'", "','", "':'", "';'", 
                     "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", 
                     "'!'", "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'", 
                     "'++'", "'--'", "'&&'", "'||'", "'->'", "'=='", "'!='", 
                     "'<='", "'>='", "'+='", "'-='", "'*='", "'/='", "'%='", 
                     "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", 
                     "'{{'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'define'", "'undef'", "'elif'", 
                     "'endif'", "'line'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'hidden'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'}}'" ]

    symbolicNames = [ "<INVALID>", "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", 
                      "EMPTY_DELIMITED_DOC_COMMENT", "DELIMITED_DOC_COMMENT", 
                      "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", "WHITESPACES", 
                      "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", 
                      "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK", 
                      "BY", "BYTE", "CASE", "CATCH", "CHAR", "CHECKED", 
                      "CLASS", "CONST", "CONTINUE", "DECIMAL", "DEFAULT", 
                      "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC", 
                      "ELSE", "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN", 
                      "FALSE", "FINALLY", "FIXED", "FLOAT", "FOR", "FOREACH", 
                      "FROM", "GET", "GOTO", "GROUP", "IF", "IMPLICIT", 
                      "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS", 
                      "JOIN", "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", 
                      "NEW", "NULL_", "OBJECT", "ON", "OPERATOR", "ORDERBY", 
                      "OUT", "OVERRIDE", "PARAMS", "PARTIAL", "PRIVATE", 
                      "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE", 
                      "RETURN", "SBYTE", "SEALED", "SELECT", "SET", "SHORT", 
                      "SIZEOF", "STACKALLOC", "STATIC", "STRING", "STRUCT", 
                      "SWITCH", "THIS", "THROW", "TRUE", "TRY", "TYPEOF", 
                      "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", 
                      "USHORT", "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", 
                      "WHEN", "WHERE", "WHILE", "YIELD", "IDENTIFIER", "LITERAL_ACCESS", 
                      "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", "BIN_INTEGER_LITERAL", 
                      "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", 
                      "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", 
                      "INTERPOLATED_VERBATIUM_STRING_START", "OPEN_BRACE", 
                      "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", 
                      "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", 
                      "PLUS", "MINUS", "STAR", "DIV", "PERCENT", "AMP", 
                      "BITWISE_OR", "CARET", "BANG", "TILDE", "ASSIGNMENT", 
                      "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", 
                      "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", 
                      "OP_NE", "OP_LE", "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", 
                      "OP_MULT_ASSIGNMENT", "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT", 
                      "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", "OP_XOR_ASSIGNMENT", 
                      "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", 
                      "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", 
                      "REGULAR_CHAR_INSIDE", "VERBATIUM_DOUBLE_QUOTE_INSIDE", 
                      "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", "VERBATIUM_INSIDE_STRING", 
                      "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", 
                      "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", 
                      "ERROR", "WARNING", "REGION", "ENDREGION", "PRAGMA", 
                      "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", 
                      "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" ]

    RULE_compilation_unit = 0
    RULE_namespace_or_type_name = 1
    RULE_type_ = 2
    RULE_base_type = 3
    RULE_tuple_type = 4
    RULE_tuple_element = 5
    RULE_simple_type = 6
    RULE_numeric_type = 7
    RULE_integral_type = 8
    RULE_floating_point_type = 9
    RULE_class_type = 10
    RULE_type_argument_list = 11
    RULE_argument_list = 12
    RULE_argument = 13
    RULE_expression = 14
    RULE_non_assignment_expression = 15
    RULE_assignment = 16
    RULE_assignment_operator = 17
    RULE_conditional_expression = 18
    RULE_null_coalescing_expression = 19
    RULE_conditional_or_expression = 20
    RULE_conditional_and_expression = 21
    RULE_inclusive_or_expression = 22
    RULE_exclusive_or_expression = 23
    RULE_and_expression = 24
    RULE_equality_expression = 25
    RULE_relational_expression = 26
    RULE_shift_expression = 27
    RULE_additive_expression = 28
    RULE_multiplicative_expression = 29
    RULE_switch_expression = 30
    RULE_switch_expression_arms = 31
    RULE_switch_expression_arm = 32
    RULE_range_expression = 33
    RULE_unary_expression = 34
    RULE_primary_expression = 35
    RULE_primary_expression_start = 36
    RULE_throwable_expression = 37
    RULE_throw_expression = 38
    RULE_member_access = 39
    RULE_bracket_expression = 40
    RULE_indexer_argument = 41
    RULE_predefined_type = 42
    RULE_expression_list = 43
    RULE_object_or_collection_initializer = 44
    RULE_object_initializer = 45
    RULE_member_initializer_list = 46
    RULE_member_initializer = 47
    RULE_initializer_value = 48
    RULE_collection_initializer = 49
    RULE_element_initializer = 50
    RULE_anonymous_object_initializer = 51
    RULE_member_declarator_list = 52
    RULE_member_declarator = 53
    RULE_unbound_type_name = 54
    RULE_generic_dimension_specifier = 55
    RULE_isType = 56
    RULE_isTypePatternArms = 57
    RULE_isTypePatternArm = 58
    RULE_lambda_expression = 59
    RULE_anonymous_function_signature = 60
    RULE_explicit_anonymous_function_parameter_list = 61
    RULE_explicit_anonymous_function_parameter = 62
    RULE_implicit_anonymous_function_parameter_list = 63
    RULE_anonymous_function_body = 64
    RULE_query_expression = 65
    RULE_from_clause = 66
    RULE_query_body = 67
    RULE_query_body_clause = 68
    RULE_let_clause = 69
    RULE_where_clause = 70
    RULE_combined_join_clause = 71
    RULE_orderby_clause = 72
    RULE_ordering = 73
    RULE_select_or_group_clause = 74
    RULE_query_continuation = 75
    RULE_statement = 76
    RULE_declarationStatement = 77
    RULE_local_function_declaration = 78
    RULE_local_function_header = 79
    RULE_local_function_modifiers = 80
    RULE_local_function_body = 81
    RULE_labeled_Statement = 82
    RULE_embedded_statement = 83
    RULE_simple_embedded_statement = 84
    RULE_block = 85
    RULE_local_variable_declaration = 86
    RULE_local_variable_type = 87
    RULE_local_variable_declarator = 88
    RULE_local_variable_initializer = 89
    RULE_local_constant_declaration = 90
    RULE_if_body = 91
    RULE_switch_section = 92
    RULE_switch_label = 93
    RULE_case_guard = 94
    RULE_statement_list = 95
    RULE_for_initializer = 96
    RULE_for_iterator = 97
    RULE_catch_clauses = 98
    RULE_specific_catch_clause = 99
    RULE_general_catch_clause = 100
    RULE_exception_filter = 101
    RULE_finally_clause = 102
    RULE_resource_acquisition = 103
    RULE_namespace_declaration = 104
    RULE_qualified_identifier = 105
    RULE_namespace_body = 106
    RULE_extern_alias_directives = 107
    RULE_extern_alias_directive = 108
    RULE_using_directives = 109
    RULE_using_directive = 110
    RULE_namespace_member_declarations = 111
    RULE_namespace_member_declaration = 112
    RULE_type_declaration = 113
    RULE_qualified_alias_member = 114
    RULE_type_parameter_list = 115
    RULE_type_parameter = 116
    RULE_class_base = 117
    RULE_interface_type_list = 118
    RULE_type_parameter_constraints_clauses = 119
    RULE_type_parameter_constraints_clause = 120
    RULE_type_parameter_constraints = 121
    RULE_primary_constraint = 122
    RULE_secondary_constraints = 123
    RULE_constructor_constraint = 124
    RULE_class_body = 125
    RULE_class_member_declarations = 126
    RULE_class_member_declaration = 127
    RULE_all_member_modifiers = 128
    RULE_all_member_modifier = 129
    RULE_common_member_declaration = 130
    RULE_typed_member_declaration = 131
    RULE_constant_declarators = 132
    RULE_constant_declarator = 133
    RULE_variable_declarators = 134
    RULE_variable_declarator = 135
    RULE_variable_initializer = 136
    RULE_return_type = 137
    RULE_member_name = 138
    RULE_method_body = 139
    RULE_formal_parameter_list = 140
    RULE_fixed_parameters = 141
    RULE_fixed_parameter = 142
    RULE_parameter_modifier = 143
    RULE_parameter_array = 144
    RULE_accessor_declarations = 145
    RULE_get_accessor_declaration = 146
    RULE_set_accessor_declaration = 147
    RULE_accessor_modifier = 148
    RULE_accessor_body = 149
    RULE_event_accessor_declarations = 150
    RULE_add_accessor_declaration = 151
    RULE_remove_accessor_declaration = 152
    RULE_overloadable_operator = 153
    RULE_conversion_operator_declarator = 154
    RULE_constructor_initializer = 155
    RULE_body = 156
    RULE_struct_interfaces = 157
    RULE_struct_body = 158
    RULE_struct_member_declaration = 159
    RULE_array_type = 160
    RULE_rank_specifier = 161
    RULE_array_initializer = 162
    RULE_variant_type_parameter_list = 163
    RULE_variant_type_parameter = 164
    RULE_variance_annotation = 165
    RULE_interface_base = 166
    RULE_interface_body = 167
    RULE_interface_member_declaration = 168
    RULE_interface_accessors = 169
    RULE_enum_base = 170
    RULE_enum_body = 171
    RULE_enum_member_declaration = 172
    RULE_global_attribute_section = 173
    RULE_global_attribute_target = 174
    RULE_attributes = 175
    RULE_attribute_section = 176
    RULE_attribute_target = 177
    RULE_attribute_list = 178
    RULE_attribute = 179
    RULE_attribute_argument = 180
    RULE_pointer_type = 181
    RULE_fixed_pointer_declarators = 182
    RULE_fixed_pointer_declarator = 183
    RULE_fixed_pointer_initializer = 184
    RULE_fixed_size_buffer_declarator = 185
    RULE_stackalloc_initializer = 186
    RULE_right_arrow = 187
    RULE_right_shift = 188
    RULE_right_shift_assignment = 189
    RULE_literal = 190
    RULE_boolean_literal = 191
    RULE_string_literal = 192
    RULE_interpolated_regular_string = 193
    RULE_interpolated_verbatium_string = 194
    RULE_interpolated_regular_string_part = 195
    RULE_interpolated_verbatium_string_part = 196
    RULE_interpolated_string_expression = 197
    RULE_keyword = 198
    RULE_class_definition = 199
    RULE_struct_definition = 200
    RULE_interface_definition = 201
    RULE_enum_definition = 202
    RULE_delegate_definition = 203
    RULE_event_declaration = 204
    RULE_field_declaration = 205
    RULE_property_declaration = 206
    RULE_constant_declaration = 207
    RULE_indexer_declaration = 208
    RULE_destructor_definition = 209
    RULE_constructor_declaration = 210
    RULE_method_declaration = 211
    RULE_method_member_name = 212
    RULE_operator_declaration = 213
    RULE_arg_declaration = 214
    RULE_method_invocation = 215
    RULE_object_creation_expression = 216
    RULE_identifier = 217

    ruleNames =  [ "compilation_unit", "namespace_or_type_name", "type_", 
                   "base_type", "tuple_type", "tuple_element", "simple_type", 
                   "numeric_type", "integral_type", "floating_point_type", 
                   "class_type", "type_argument_list", "argument_list", 
                   "argument", "expression", "non_assignment_expression", 
                   "assignment", "assignment_operator", "conditional_expression", 
                   "null_coalescing_expression", "conditional_or_expression", 
                   "conditional_and_expression", "inclusive_or_expression", 
                   "exclusive_or_expression", "and_expression", "equality_expression", 
                   "relational_expression", "shift_expression", "additive_expression", 
                   "multiplicative_expression", "switch_expression", "switch_expression_arms", 
                   "switch_expression_arm", "range_expression", "unary_expression", 
                   "primary_expression", "primary_expression_start", "throwable_expression", 
                   "throw_expression", "member_access", "bracket_expression", 
                   "indexer_argument", "predefined_type", "expression_list", 
                   "object_or_collection_initializer", "object_initializer", 
                   "member_initializer_list", "member_initializer", "initializer_value", 
                   "collection_initializer", "element_initializer", "anonymous_object_initializer", 
                   "member_declarator_list", "member_declarator", "unbound_type_name", 
                   "generic_dimension_specifier", "isType", "isTypePatternArms", 
                   "isTypePatternArm", "lambda_expression", "anonymous_function_signature", 
                   "explicit_anonymous_function_parameter_list", "explicit_anonymous_function_parameter", 
                   "implicit_anonymous_function_parameter_list", "anonymous_function_body", 
                   "query_expression", "from_clause", "query_body", "query_body_clause", 
                   "let_clause", "where_clause", "combined_join_clause", 
                   "orderby_clause", "ordering", "select_or_group_clause", 
                   "query_continuation", "statement", "declarationStatement", 
                   "local_function_declaration", "local_function_header", 
                   "local_function_modifiers", "local_function_body", "labeled_Statement", 
                   "embedded_statement", "simple_embedded_statement", "block", 
                   "local_variable_declaration", "local_variable_type", 
                   "local_variable_declarator", "local_variable_initializer", 
                   "local_constant_declaration", "if_body", "switch_section", 
                   "switch_label", "case_guard", "statement_list", "for_initializer", 
                   "for_iterator", "catch_clauses", "specific_catch_clause", 
                   "general_catch_clause", "exception_filter", "finally_clause", 
                   "resource_acquisition", "namespace_declaration", "qualified_identifier", 
                   "namespace_body", "extern_alias_directives", "extern_alias_directive", 
                   "using_directives", "using_directive", "namespace_member_declarations", 
                   "namespace_member_declaration", "type_declaration", "qualified_alias_member", 
                   "type_parameter_list", "type_parameter", "class_base", 
                   "interface_type_list", "type_parameter_constraints_clauses", 
                   "type_parameter_constraints_clause", "type_parameter_constraints", 
                   "primary_constraint", "secondary_constraints", "constructor_constraint", 
                   "class_body", "class_member_declarations", "class_member_declaration", 
                   "all_member_modifiers", "all_member_modifier", "common_member_declaration", 
                   "typed_member_declaration", "constant_declarators", "constant_declarator", 
                   "variable_declarators", "variable_declarator", "variable_initializer", 
                   "return_type", "member_name", "method_body", "formal_parameter_list", 
                   "fixed_parameters", "fixed_parameter", "parameter_modifier", 
                   "parameter_array", "accessor_declarations", "get_accessor_declaration", 
                   "set_accessor_declaration", "accessor_modifier", "accessor_body", 
                   "event_accessor_declarations", "add_accessor_declaration", 
                   "remove_accessor_declaration", "overloadable_operator", 
                   "conversion_operator_declarator", "constructor_initializer", 
                   "body", "struct_interfaces", "struct_body", "struct_member_declaration", 
                   "array_type", "rank_specifier", "array_initializer", 
                   "variant_type_parameter_list", "variant_type_parameter", 
                   "variance_annotation", "interface_base", "interface_body", 
                   "interface_member_declaration", "interface_accessors", 
                   "enum_base", "enum_body", "enum_member_declaration", 
                   "global_attribute_section", "global_attribute_target", 
                   "attributes", "attribute_section", "attribute_target", 
                   "attribute_list", "attribute", "attribute_argument", 
                   "pointer_type", "fixed_pointer_declarators", "fixed_pointer_declarator", 
                   "fixed_pointer_initializer", "fixed_size_buffer_declarator", 
                   "stackalloc_initializer", "right_arrow", "right_shift", 
                   "right_shift_assignment", "literal", "boolean_literal", 
                   "string_literal", "interpolated_regular_string", "interpolated_verbatium_string", 
                   "interpolated_regular_string_part", "interpolated_verbatium_string_part", 
                   "interpolated_string_expression", "keyword", "class_definition", 
                   "struct_definition", "interface_definition", "enum_definition", 
                   "delegate_definition", "event_declaration", "field_declaration", 
                   "property_declaration", "constant_declaration", "indexer_declaration", 
                   "destructor_definition", "constructor_declaration", "method_declaration", 
                   "method_member_name", "operator_declaration", "arg_declaration", 
                   "method_invocation", "object_creation_expression", "identifier" ]

    EOF = Token.EOF
    BYTE_ORDER_MARK=1
    SINGLE_LINE_DOC_COMMENT=2
    EMPTY_DELIMITED_DOC_COMMENT=3
    DELIMITED_DOC_COMMENT=4
    SINGLE_LINE_COMMENT=5
    DELIMITED_COMMENT=6
    WHITESPACES=7
    SHARP=8
    ABSTRACT=9
    ADD=10
    ALIAS=11
    ARGLIST=12
    AS=13
    ASCENDING=14
    ASYNC=15
    AWAIT=16
    BASE=17
    BOOL=18
    BREAK=19
    BY=20
    BYTE=21
    CASE=22
    CATCH=23
    CHAR=24
    CHECKED=25
    CLASS=26
    CONST=27
    CONTINUE=28
    DECIMAL=29
    DEFAULT=30
    DELEGATE=31
    DESCENDING=32
    DO=33
    DOUBLE=34
    DYNAMIC=35
    ELSE=36
    ENUM=37
    EQUALS=38
    EVENT=39
    EXPLICIT=40
    EXTERN=41
    FALSE=42
    FINALLY=43
    FIXED=44
    FLOAT=45
    FOR=46
    FOREACH=47
    FROM=48
    GET=49
    GOTO=50
    GROUP=51
    IF=52
    IMPLICIT=53
    IN=54
    INT=55
    INTERFACE=56
    INTERNAL=57
    INTO=58
    IS=59
    JOIN=60
    LET=61
    LOCK=62
    LONG=63
    NAMEOF=64
    NAMESPACE=65
    NEW=66
    NULL_=67
    OBJECT=68
    ON=69
    OPERATOR=70
    ORDERBY=71
    OUT=72
    OVERRIDE=73
    PARAMS=74
    PARTIAL=75
    PRIVATE=76
    PROTECTED=77
    PUBLIC=78
    READONLY=79
    REF=80
    REMOVE=81
    RETURN=82
    SBYTE=83
    SEALED=84
    SELECT=85
    SET=86
    SHORT=87
    SIZEOF=88
    STACKALLOC=89
    STATIC=90
    STRING=91
    STRUCT=92
    SWITCH=93
    THIS=94
    THROW=95
    TRUE=96
    TRY=97
    TYPEOF=98
    UINT=99
    ULONG=100
    UNCHECKED=101
    UNMANAGED=102
    UNSAFE=103
    USHORT=104
    USING=105
    VAR=106
    VIRTUAL=107
    VOID=108
    VOLATILE=109
    WHEN=110
    WHERE=111
    WHILE=112
    YIELD=113
    IDENTIFIER=114
    LITERAL_ACCESS=115
    INTEGER_LITERAL=116
    HEX_INTEGER_LITERAL=117
    BIN_INTEGER_LITERAL=118
    REAL_LITERAL=119
    CHARACTER_LITERAL=120
    REGULAR_STRING=121
    VERBATIUM_STRING=122
    INTERPOLATED_REGULAR_STRING_START=123
    INTERPOLATED_VERBATIUM_STRING_START=124
    OPEN_BRACE=125
    CLOSE_BRACE=126
    OPEN_BRACKET=127
    CLOSE_BRACKET=128
    OPEN_PARENS=129
    CLOSE_PARENS=130
    DOT=131
    COMMA=132
    COLON=133
    SEMICOLON=134
    PLUS=135
    MINUS=136
    STAR=137
    DIV=138
    PERCENT=139
    AMP=140
    BITWISE_OR=141
    CARET=142
    BANG=143
    TILDE=144
    ASSIGNMENT=145
    LT=146
    GT=147
    INTERR=148
    DOUBLE_COLON=149
    OP_COALESCING=150
    OP_INC=151
    OP_DEC=152
    OP_AND=153
    OP_OR=154
    OP_PTR=155
    OP_EQ=156
    OP_NE=157
    OP_LE=158
    OP_GE=159
    OP_ADD_ASSIGNMENT=160
    OP_SUB_ASSIGNMENT=161
    OP_MULT_ASSIGNMENT=162
    OP_DIV_ASSIGNMENT=163
    OP_MOD_ASSIGNMENT=164
    OP_AND_ASSIGNMENT=165
    OP_OR_ASSIGNMENT=166
    OP_XOR_ASSIGNMENT=167
    OP_LEFT_SHIFT=168
    OP_LEFT_SHIFT_ASSIGNMENT=169
    OP_COALESCING_ASSIGNMENT=170
    OP_RANGE=171
    DOUBLE_CURLY_INSIDE=172
    OPEN_BRACE_INSIDE=173
    REGULAR_CHAR_INSIDE=174
    VERBATIUM_DOUBLE_QUOTE_INSIDE=175
    DOUBLE_QUOTE_INSIDE=176
    REGULAR_STRING_INSIDE=177
    VERBATIUM_INSIDE_STRING=178
    CLOSE_BRACE_INSIDE=179
    FORMAT_STRING=180
    DIRECTIVE_WHITESPACES=181
    DIGITS=182
    DEFINE=183
    UNDEF=184
    ELIF=185
    ENDIF=186
    LINE=187
    ERROR=188
    WARNING=189
    REGION=190
    ENDREGION=191
    PRAGMA=192
    NULLABLE=193
    DIRECTIVE_HIDDEN=194
    CONDITIONAL_SYMBOL=195
    DIRECTIVE_NEW_LINE=196
    TEXT=197
    DOUBLE_CURLY_CLOSE_INSIDE=198

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




    class Compilation_unitContext(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(CSharpParser.EOF, 0)

        def BYTE_ORDER_MARK(self):
            return self.getToken(CSharpParser.BYTE_ORDER_MARK, 0)

        def extern_alias_directives(self):
            return self.getTypedRuleContext(CSharpParser.Extern_alias_directivesContext,0)


        def using_directives(self):
            return self.getTypedRuleContext(CSharpParser.Using_directivesContext,0)


        def global_attribute_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Global_attribute_sectionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Global_attribute_sectionContext,i)


        def namespace_member_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_compilation_unit

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

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




    def compilation_unit(self):

        localctx = CSharpParser.Compilation_unitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_compilation_unit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 437
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.BYTE_ORDER_MARK:
                self.state = 436
                self.match(CSharpParser.BYTE_ORDER_MARK)


            self.state = 440
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.state = 439
                self.extern_alias_directives()


            self.state = 443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.USING:
                self.state = 442
                self.using_directives()


            self.state = 448
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 445
                    self.global_attribute_section() 
                self.state = 450
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

            self.state = 452
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NAMESPACE - 65)) | (1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 0):
                self.state = 451
                self.namespace_member_declarations()


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


    class Namespace_or_type_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def qualified_alias_member(self):
            return self.getTypedRuleContext(CSharpParser.Qualified_alias_memberContext,0)


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

        def type_argument_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_argument_listContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_or_type_name

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

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




    def namespace_or_type_name(self):

        localctx = CSharpParser.Namespace_or_type_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_namespace_or_type_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 461
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.state = 456
                self.identifier()
                self.state = 458
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
                if la_ == 1:
                    self.state = 457
                    self.type_argument_list()


                pass

            elif la_ == 2:
                self.state = 460
                self.qualified_alias_member()
                pass


            self.state = 470
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 463
                    self.match(CSharpParser.DOT)
                    self.state = 464
                    self.identifier()
                    self.state = 466
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                    if la_ == 1:
                        self.state = 465
                        self.type_argument_list()

             
                self.state = 472
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,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 Type_Context(ParserRuleContext):
        __slots__ = 'parser'

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

        def base_type(self):
            return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)


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

        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_type_

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

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




    def type_(self):

        localctx = CSharpParser.Type_Context(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_type_)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self.base_type()
            self.state = 479
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 477
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.INTERR]:
                        self.state = 474
                        self.match(CSharpParser.INTERR)
                        pass
                    elif token in [CSharpParser.OPEN_BRACKET]:
                        self.state = 475
                        self.rank_specifier()
                        pass
                    elif token in [CSharpParser.STAR]:
                        self.state = 476
                        self.match(CSharpParser.STAR)
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 481
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,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 Base_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def simple_type(self):
            return self.getTypedRuleContext(CSharpParser.Simple_typeContext,0)


        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

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

        def tuple_type(self):
            return self.getTypedRuleContext(CSharpParser.Tuple_typeContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_base_type

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

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




    def base_type(self):

        localctx = CSharpParser.Base_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_base_type)
        try:
            self.state = 487
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.BOOL, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 482
                self.simple_type()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 483
                self.class_type()
                pass
            elif token in [CSharpParser.VOID]:
                self.enterOuterAlt(localctx, 3)
                self.state = 484
                self.match(CSharpParser.VOID)
                self.state = 485
                self.match(CSharpParser.STAR)
                pass
            elif token in [CSharpParser.OPEN_PARENS]:
                self.enterOuterAlt(localctx, 4)
                self.state = 486
                self.tuple_type()
                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 Tuple_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def tuple_element(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Tuple_elementContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Tuple_elementContext,i)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_tuple_type

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

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




    def tuple_type(self):

        localctx = CSharpParser.Tuple_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_tuple_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 490
            self.tuple_element()
            self.state = 493 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 491
                self.match(CSharpParser.COMMA)
                self.state = 492
                self.tuple_element()
                self.state = 495 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.COMMA):
                    break

            self.state = 497
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Tuple_elementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_tuple_element

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

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




    def tuple_element(self):

        localctx = CSharpParser.Tuple_elementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_tuple_element)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 499
            self.type_()
            self.state = 501
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)))) != 0):
                self.state = 500
                self.identifier()


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


    class Simple_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def numeric_type(self):
            return self.getTypedRuleContext(CSharpParser.Numeric_typeContext,0)


        def BOOL(self):
            return self.getToken(CSharpParser.BOOL, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_simple_type

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

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




    def simple_type(self):

        localctx = CSharpParser.Simple_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_simple_type)
        try:
            self.state = 505
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 503
                self.numeric_type()
                pass
            elif token in [CSharpParser.BOOL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 504
                self.match(CSharpParser.BOOL)
                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 Numeric_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def integral_type(self):
            return self.getTypedRuleContext(CSharpParser.Integral_typeContext,0)


        def floating_point_type(self):
            return self.getTypedRuleContext(CSharpParser.Floating_point_typeContext,0)


        def DECIMAL(self):
            return self.getToken(CSharpParser.DECIMAL, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_numeric_type

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

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




    def numeric_type(self):

        localctx = CSharpParser.Numeric_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_numeric_type)
        try:
            self.state = 510
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 507
                self.integral_type()
                pass
            elif token in [CSharpParser.DOUBLE, CSharpParser.FLOAT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 508
                self.floating_point_type()
                pass
            elif token in [CSharpParser.DECIMAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 509
                self.match(CSharpParser.DECIMAL)
                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 Integral_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SBYTE(self):
            return self.getToken(CSharpParser.SBYTE, 0)

        def BYTE(self):
            return self.getToken(CSharpParser.BYTE, 0)

        def SHORT(self):
            return self.getToken(CSharpParser.SHORT, 0)

        def USHORT(self):
            return self.getToken(CSharpParser.USHORT, 0)

        def INT(self):
            return self.getToken(CSharpParser.INT, 0)

        def UINT(self):
            return self.getToken(CSharpParser.UINT, 0)

        def LONG(self):
            return self.getToken(CSharpParser.LONG, 0)

        def ULONG(self):
            return self.getToken(CSharpParser.ULONG, 0)

        def CHAR(self):
            return self.getToken(CSharpParser.CHAR, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_integral_type

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

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




    def integral_type(self):

        localctx = CSharpParser.Integral_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_integral_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 512
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.INT) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CSharpParser.SBYTE - 83)) | (1 << (CSharpParser.SHORT - 83)) | (1 << (CSharpParser.UINT - 83)) | (1 << (CSharpParser.ULONG - 83)) | (1 << (CSharpParser.USHORT - 83)))) != 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 Floating_point_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FLOAT(self):
            return self.getToken(CSharpParser.FLOAT, 0)

        def DOUBLE(self):
            return self.getToken(CSharpParser.DOUBLE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_floating_point_type

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

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




    def floating_point_type(self):

        localctx = CSharpParser.Floating_point_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_floating_point_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 514
            _la = self._input.LA(1)
            if not(_la==CSharpParser.DOUBLE or _la==CSharpParser.FLOAT):
                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 Class_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


        def OBJECT(self):
            return self.getToken(CSharpParser.OBJECT, 0)

        def DYNAMIC(self):
            return self.getToken(CSharpParser.DYNAMIC, 0)

        def STRING(self):
            return self.getToken(CSharpParser.STRING, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_class_type

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

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




    def class_type(self):

        localctx = CSharpParser.Class_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_class_type)
        try:
            self.state = 520
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 516
                self.namespace_or_type_name()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 517
                self.match(CSharpParser.OBJECT)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 518
                self.match(CSharpParser.DYNAMIC)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 519
                self.match(CSharpParser.STRING)
                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_argument_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def type_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_Context)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_Context,i)


        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_type_argument_list

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

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




    def type_argument_list(self):

        localctx = CSharpParser.Type_argument_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_type_argument_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 522
            self.match(CSharpParser.LT)
            self.state = 523
            self.type_()
            self.state = 528
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 524
                self.match(CSharpParser.COMMA)
                self.state = 525
                self.type_()
                self.state = 530
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 531
            self.match(CSharpParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Argument_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_argument_list

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

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




    def argument_list(self):

        localctx = CSharpParser.Argument_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_argument_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 533
            self.argument()
            self.state = 538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 534
                self.match(CSharpParser.COMMA)
                self.state = 535
                self.argument()
                self.state = 540
                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 ArgumentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

        def VAR(self):
            return self.getToken(CSharpParser.VAR, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_argument

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

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




    def argument(self):

        localctx = CSharpParser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_argument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.state = 541
                self.identifier()
                self.state = 542
                self.match(CSharpParser.COLON)


            self.state = 547
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.state = 546
                localctx.refout = self._input.LT(1)
                _la = self._input.LA(1)
                if not(((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)))) != 0)):
                    localctx.refout = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 551
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 549
                self.match(CSharpParser.VAR)

            elif la_ == 2:
                self.state = 550
                self.type_()


            self.state = 553
            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 ExpressionContext(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(CSharpParser.AssignmentContext,0)


        def non_assignment_expression(self):
            return self.getTypedRuleContext(CSharpParser.Non_assignment_expressionContext,0)


        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_expression

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

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




    def expression(self):

        localctx = CSharpParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_expression)
        try:
            self.state = 559
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 555
                self.assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 556
                self.non_assignment_expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 557
                self.match(CSharpParser.REF)
                self.state = 558
                self.non_assignment_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 Non_assignment_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def lambda_expression(self):
            return self.getTypedRuleContext(CSharpParser.Lambda_expressionContext,0)


        def query_expression(self):
            return self.getTypedRuleContext(CSharpParser.Query_expressionContext,0)


        def conditional_expression(self):
            return self.getTypedRuleContext(CSharpParser.Conditional_expressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_non_assignment_expression

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

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




    def non_assignment_expression(self):

        localctx = CSharpParser.Non_assignment_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_non_assignment_expression)
        try:
            self.state = 564
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 561
                self.lambda_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 562
                self.query_expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 563
                self.conditional_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 AssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unary_expression(self):
            return self.getTypedRuleContext(CSharpParser.Unary_expressionContext,0)


        def assignment_operator(self):
            return self.getTypedRuleContext(CSharpParser.Assignment_operatorContext,0)


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


        def OP_COALESCING_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_COALESCING_ASSIGNMENT, 0)

        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_assignment

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

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




    def assignment(self):

        localctx = CSharpParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_assignment)
        try:
            self.state = 574
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 566
                self.unary_expression()
                self.state = 567
                self.assignment_operator()
                self.state = 568
                self.expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 570
                self.unary_expression()
                self.state = 571
                self.match(CSharpParser.OP_COALESCING_ASSIGNMENT)
                self.state = 572
                self.throwable_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 Assignment_operatorContext(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.getToken(CSharpParser.ASSIGNMENT, 0)

        def OP_ADD_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_ADD_ASSIGNMENT, 0)

        def OP_SUB_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_SUB_ASSIGNMENT, 0)

        def OP_MULT_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_MULT_ASSIGNMENT, 0)

        def OP_DIV_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_DIV_ASSIGNMENT, 0)

        def OP_MOD_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_MOD_ASSIGNMENT, 0)

        def OP_AND_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_AND_ASSIGNMENT, 0)

        def OP_OR_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_OR_ASSIGNMENT, 0)

        def OP_XOR_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_XOR_ASSIGNMENT, 0)

        def OP_LEFT_SHIFT_ASSIGNMENT(self):
            return self.getToken(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT, 0)

        def right_shift_assignment(self):
            return self.getTypedRuleContext(CSharpParser.Right_shift_assignmentContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_assignment_operator

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

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




    def assignment_operator(self):

        localctx = CSharpParser.Assignment_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_assignment_operator)
        try:
            self.state = 587
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ASSIGNMENT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 576
                self.match(CSharpParser.ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_ADD_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 577
                self.match(CSharpParser.OP_ADD_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_SUB_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 578
                self.match(CSharpParser.OP_SUB_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_MULT_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 579
                self.match(CSharpParser.OP_MULT_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_DIV_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 580
                self.match(CSharpParser.OP_DIV_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_MOD_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 6)
                self.state = 581
                self.match(CSharpParser.OP_MOD_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_AND_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 7)
                self.state = 582
                self.match(CSharpParser.OP_AND_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_OR_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 8)
                self.state = 583
                self.match(CSharpParser.OP_OR_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_XOR_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 9)
                self.state = 584
                self.match(CSharpParser.OP_XOR_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 10)
                self.state = 585
                self.match(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT)
                pass
            elif token in [CSharpParser.GT]:
                self.enterOuterAlt(localctx, 11)
                self.state = 586
                self.right_shift_assignment()
                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 Conditional_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def null_coalescing_expression(self):
            return self.getTypedRuleContext(CSharpParser.Null_coalescing_expressionContext,0)


        def INTERR(self):
            return self.getToken(CSharpParser.INTERR, 0)

        def throwable_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Throwable_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_conditional_expression

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

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




    def conditional_expression(self):

        localctx = CSharpParser.Conditional_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_conditional_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 589
            self.null_coalescing_expression()
            self.state = 595
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.state = 590
                self.match(CSharpParser.INTERR)
                self.state = 591
                self.throwable_expression()
                self.state = 592
                self.match(CSharpParser.COLON)
                self.state = 593
                self.throwable_expression()


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


    class Null_coalescing_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def conditional_or_expression(self):
            return self.getTypedRuleContext(CSharpParser.Conditional_or_expressionContext,0)


        def OP_COALESCING(self):
            return self.getToken(CSharpParser.OP_COALESCING, 0)

        def null_coalescing_expression(self):
            return self.getTypedRuleContext(CSharpParser.Null_coalescing_expressionContext,0)


        def throw_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throw_expressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_null_coalescing_expression

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

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




    def null_coalescing_expression(self):

        localctx = CSharpParser.Null_coalescing_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_null_coalescing_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 597
            self.conditional_or_expression()
            self.state = 603
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
            if la_ == 1:
                self.state = 598
                self.match(CSharpParser.OP_COALESCING)
                self.state = 601
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                    self.state = 599
                    self.null_coalescing_expression()
                    pass
                elif token in [CSharpParser.THROW]:
                    self.state = 600
                    self.throw_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 Conditional_or_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def conditional_and_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Conditional_and_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Conditional_and_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_conditional_or_expression

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

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




    def conditional_or_expression(self):

        localctx = CSharpParser.Conditional_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_conditional_or_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            self.conditional_and_expression()
            self.state = 610
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 606
                    self.match(CSharpParser.OP_OR)
                    self.state = 607
                    self.conditional_and_expression() 
                self.state = 612
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,29,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 Conditional_and_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def inclusive_or_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Inclusive_or_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Inclusive_or_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_conditional_and_expression

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

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




    def conditional_and_expression(self):

        localctx = CSharpParser.Conditional_and_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_conditional_and_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 613
            self.inclusive_or_expression()
            self.state = 618
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,30,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 614
                    self.match(CSharpParser.OP_AND)
                    self.state = 615
                    self.inclusive_or_expression() 
                self.state = 620
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,30,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 Inclusive_or_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def exclusive_or_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Exclusive_or_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Exclusive_or_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_inclusive_or_expression

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

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




    def inclusive_or_expression(self):

        localctx = CSharpParser.Inclusive_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_inclusive_or_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 621
            self.exclusive_or_expression()
            self.state = 626
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,31,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 622
                    self.match(CSharpParser.BITWISE_OR)
                    self.state = 623
                    self.exclusive_or_expression() 
                self.state = 628
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,31,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 Exclusive_or_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def and_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.And_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.And_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_exclusive_or_expression

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

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




    def exclusive_or_expression(self):

        localctx = CSharpParser.Exclusive_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_exclusive_or_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 629
            self.and_expression()
            self.state = 634
            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 = 630
                    self.match(CSharpParser.CARET)
                    self.state = 631
                    self.and_expression() 
                self.state = 636
                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 And_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def equality_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Equality_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Equality_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_and_expression

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

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




    def and_expression(self):

        localctx = CSharpParser.And_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_and_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637
            self.equality_expression()
            self.state = 642
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,33,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 638
                    self.match(CSharpParser.AMP)
                    self.state = 639
                    self.equality_expression() 
                self.state = 644
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,33,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 Equality_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def relational_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Relational_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Relational_expressionContext,i)


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_equality_expression

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

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




    def equality_expression(self):

        localctx = CSharpParser.Equality_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_equality_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 645
            self.relational_expression()
            self.state = 650
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 646
                    _la = self._input.LA(1)
                    if not(_la==CSharpParser.OP_EQ or _la==CSharpParser.OP_NE):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 647
                    self.relational_expression() 
                self.state = 652
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,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 Relational_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def shift_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Shift_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Shift_expressionContext,i)


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

        def isType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IsTypeContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IsTypeContext,i)


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

        def type_(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_Context)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_Context,i)


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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_relational_expression

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

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




    def relational_expression(self):

        localctx = CSharpParser.Relational_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_relational_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 653
            self.shift_expression()
            self.state = 662
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 660
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.LT, CSharpParser.GT, CSharpParser.OP_LE, CSharpParser.OP_GE]:
                        self.state = 654
                        _la = self._input.LA(1)
                        if not(((((_la - 146)) & ~0x3f) == 0 and ((1 << (_la - 146)) & ((1 << (CSharpParser.LT - 146)) | (1 << (CSharpParser.GT - 146)) | (1 << (CSharpParser.OP_LE - 146)) | (1 << (CSharpParser.OP_GE - 146)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 655
                        self.shift_expression()
                        pass
                    elif token in [CSharpParser.IS]:
                        self.state = 656
                        self.match(CSharpParser.IS)
                        self.state = 657
                        self.isType()
                        pass
                    elif token in [CSharpParser.AS]:
                        self.state = 658
                        self.match(CSharpParser.AS)
                        self.state = 659
                        self.type_()
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 664
                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.exitRule()
        return localctx


    class Shift_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def additive_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Additive_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Additive_expressionContext,i)


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

        def right_shift(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Right_shiftContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Right_shiftContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_shift_expression

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

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




    def shift_expression(self):

        localctx = CSharpParser.Shift_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_shift_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 665
            self.additive_expression()
            self.state = 673
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 668
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.OP_LEFT_SHIFT]:
                        self.state = 666
                        self.match(CSharpParser.OP_LEFT_SHIFT)
                        pass
                    elif token in [CSharpParser.GT]:
                        self.state = 667
                        self.right_shift()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 670
                    self.additive_expression() 
                self.state = 675
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,38,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 Additive_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def multiplicative_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Multiplicative_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Multiplicative_expressionContext,i)


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_additive_expression

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

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




    def additive_expression(self):

        localctx = CSharpParser.Additive_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_additive_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 676
            self.multiplicative_expression()
            self.state = 681
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,39,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 677
                    _la = self._input.LA(1)
                    if not(_la==CSharpParser.PLUS or _la==CSharpParser.MINUS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 678
                    self.multiplicative_expression() 
                self.state = 683
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,39,self._ctx)

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


    class Multiplicative_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def switch_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Switch_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Switch_expressionContext,i)


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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_multiplicative_expression

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

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




    def multiplicative_expression(self):

        localctx = CSharpParser.Multiplicative_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_multiplicative_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 684
            self.switch_expression()
            self.state = 689
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 685
                    _la = self._input.LA(1)
                    if not(((((_la - 137)) & ~0x3f) == 0 and ((1 << (_la - 137)) & ((1 << (CSharpParser.STAR - 137)) | (1 << (CSharpParser.DIV - 137)) | (1 << (CSharpParser.PERCENT - 137)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 686
                    self.switch_expression() 
                self.state = 691
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,40,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 Switch_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def range_expression(self):
            return self.getTypedRuleContext(CSharpParser.Range_expressionContext,0)


        def SWITCH(self):
            return self.getToken(CSharpParser.SWITCH, 0)

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

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

        def switch_expression_arms(self):
            return self.getTypedRuleContext(CSharpParser.Switch_expression_armsContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_switch_expression

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

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




    def switch_expression(self):

        localctx = CSharpParser.Switch_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_switch_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 692
            self.range_expression()
            self.state = 702
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 693
                self.match(CSharpParser.SWITCH)
                self.state = 694
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 695
                    self.switch_expression_arms()
                    self.state = 697
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.COMMA:
                        self.state = 696
                        self.match(CSharpParser.COMMA)




                self.state = 701
                self.match(CSharpParser.CLOSE_BRACE)


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


    class Switch_expression_armsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def switch_expression_arm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Switch_expression_armContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Switch_expression_armContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_switch_expression_arms

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

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




    def switch_expression_arms(self):

        localctx = CSharpParser.Switch_expression_armsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_switch_expression_arms)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 704
            self.switch_expression_arm()
            self.state = 709
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 705
                    self.match(CSharpParser.COMMA)
                    self.state = 706
                    self.switch_expression_arm() 
                self.state = 711
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,44,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 Switch_expression_armContext(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(CSharpParser.ExpressionContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def case_guard(self):
            return self.getTypedRuleContext(CSharpParser.Case_guardContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_switch_expression_arm

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

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




    def switch_expression_arm(self):

        localctx = CSharpParser.Switch_expression_armContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_switch_expression_arm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 712
            self.expression()
            self.state = 714
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHEN:
                self.state = 713
                self.case_guard()


            self.state = 716
            self.right_arrow()
            self.state = 717
            self.throwable_expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Range_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def unary_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Unary_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Unary_expressionContext,i)


        def OP_RANGE(self):
            return self.getToken(CSharpParser.OP_RANGE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_range_expression

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

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




    def range_expression(self):

        localctx = CSharpParser.Range_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_range_expression)
        self._la = 0 # Token type
        try:
            self.state = 727
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 719
                self.unary_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 721
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)))) != 0):
                    self.state = 720
                    self.unary_expression()


                self.state = 723
                self.match(CSharpParser.OP_RANGE)
                self.state = 725
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
                if la_ == 1:
                    self.state = 724
                    self.unary_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 Unary_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def primary_expression(self):
            return self.getTypedRuleContext(CSharpParser.Primary_expressionContext,0)


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

        def unary_expression(self):
            return self.getTypedRuleContext(CSharpParser.Unary_expressionContext,0)


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

        def BANG(self):
            return self.getToken(CSharpParser.BANG, 0)

        def TILDE(self):
            return self.getToken(CSharpParser.TILDE, 0)

        def OP_INC(self):
            return self.getToken(CSharpParser.OP_INC, 0)

        def OP_DEC(self):
            return self.getToken(CSharpParser.OP_DEC, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

        def AMP(self):
            return self.getToken(CSharpParser.AMP, 0)

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

        def CARET(self):
            return self.getToken(CSharpParser.CARET, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_unary_expression

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

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




    def unary_expression(self):

        localctx = CSharpParser.Unary_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_unary_expression)
        try:
            self.state = 755
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 729
                self.primary_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 730
                self.match(CSharpParser.PLUS)
                self.state = 731
                self.unary_expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 732
                self.match(CSharpParser.MINUS)
                self.state = 733
                self.unary_expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 734
                self.match(CSharpParser.BANG)
                self.state = 735
                self.unary_expression()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 736
                self.match(CSharpParser.TILDE)
                self.state = 737
                self.unary_expression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 738
                self.match(CSharpParser.OP_INC)
                self.state = 739
                self.unary_expression()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 740
                self.match(CSharpParser.OP_DEC)
                self.state = 741
                self.unary_expression()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 742
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 743
                self.type_()
                self.state = 744
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 745
                self.unary_expression()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 747
                self.match(CSharpParser.AWAIT)
                self.state = 748
                self.unary_expression()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 749
                self.match(CSharpParser.AMP)
                self.state = 750
                self.unary_expression()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 751
                self.match(CSharpParser.STAR)
                self.state = 752
                self.unary_expression()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 753
                self.match(CSharpParser.CARET)
                self.state = 754
                self.unary_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 Primary_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def primary_expression_start(self):
            return self.getTypedRuleContext(CSharpParser.Primary_expression_startContext,0)


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

        def bracket_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Bracket_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Bracket_expressionContext,i)


        def member_access(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Member_accessContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Member_accessContext,i)


        def method_invocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Method_invocationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Method_invocationContext,i)


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

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

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_primary_expression

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

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




    def primary_expression(self):

        localctx = CSharpParser.Primary_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_primary_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 757
            localctx.pe = self.primary_expression_start()
            self.state = 759
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
            if la_ == 1:
                self.state = 758
                self.match(CSharpParser.BANG)


            self.state = 764
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,51,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 761
                    self.bracket_expression() 
                self.state = 766
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,51,self._ctx)

            self.state = 768
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 767
                self.match(CSharpParser.BANG)


            self.state = 792
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,57,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 776
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.DOT, CSharpParser.INTERR]:
                        self.state = 770
                        self.member_access()
                        pass
                    elif token in [CSharpParser.OPEN_PARENS]:
                        self.state = 771
                        self.method_invocation()
                        pass
                    elif token in [CSharpParser.OP_INC]:
                        self.state = 772
                        self.match(CSharpParser.OP_INC)
                        pass
                    elif token in [CSharpParser.OP_DEC]:
                        self.state = 773
                        self.match(CSharpParser.OP_DEC)
                        pass
                    elif token in [CSharpParser.OP_PTR]:
                        self.state = 774
                        self.match(CSharpParser.OP_PTR)
                        self.state = 775
                        self.identifier()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 779
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
                    if la_ == 1:
                        self.state = 778
                        self.match(CSharpParser.BANG)


                    self.state = 784
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,55,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 781
                            self.bracket_expression() 
                        self.state = 786
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,55,self._ctx)

                    self.state = 788
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
                    if la_ == 1:
                        self.state = 787
                        self.match(CSharpParser.BANG)

             
                self.state = 794
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,57,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 Primary_expression_startContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CSharpParser.RULE_primary_expression_start

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



    class LiteralAccessExpressionContext(Primary_expression_startContext):

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

        def LITERAL_ACCESS(self):
            return self.getToken(CSharpParser.LITERAL_ACCESS, 0)

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

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


    class DefaultValueExpressionContext(Primary_expression_startContext):

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

        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

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


    class BaseAccessExpressionContext(Primary_expression_startContext):

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

        def BASE(self):
            return self.getToken(CSharpParser.BASE, 0)
        def DOT(self):
            return self.getToken(CSharpParser.DOT, 0)
        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)
        def expression_list(self):
            return self.getTypedRuleContext(CSharpParser.Expression_listContext,0)

        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)
        def type_argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)


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

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


    class SizeofExpressionContext(Primary_expression_startContext):

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

        def SIZEOF(self):
            return self.getToken(CSharpParser.SIZEOF, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

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


    class ParenthesisExpressionsContext(Primary_expression_startContext):

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

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

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


    class ThisReferenceExpressionContext(Primary_expression_startContext):

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

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

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

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


    class ObjectCreationExpressionContext(Primary_expression_startContext):

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

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)
        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)

        def anonymous_object_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Anonymous_object_initializerContext,0)

        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)

        def array_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)

        def object_creation_expression(self):
            return self.getTypedRuleContext(CSharpParser.Object_creation_expressionContext,0)

        def object_or_collection_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)
        def expression_list(self):
            return self.getTypedRuleContext(CSharpParser.Expression_listContext,0)

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

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

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


    class AnonymousMethodExpressionContext(Primary_expression_startContext):

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

        def DELEGATE(self):
            return self.getToken(CSharpParser.DELEGATE, 0)
        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)

        def ASYNC(self):
            return self.getToken(CSharpParser.ASYNC, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def explicit_anonymous_function_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Explicit_anonymous_function_parameter_listContext,0)


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

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


    class TypeofExpressionContext(Primary_expression_startContext):

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

        def TYPEOF(self):
            return self.getToken(CSharpParser.TYPEOF, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def unbound_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Unbound_type_nameContext,0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)

        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

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

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


    class TupleExpressionContext(Primary_expression_startContext):

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

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.ArgumentContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ArgumentContext,i)

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

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

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


    class UncheckedExpressionContext(Primary_expression_startContext):

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

        def UNCHECKED(self):
            return self.getToken(CSharpParser.UNCHECKED, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

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


    class SimpleNameExpressionContext(Primary_expression_startContext):

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

        def type_argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)


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

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


    class MemberAccessExpressionContext(Primary_expression_startContext):

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

        def predefined_type(self):
            return self.getTypedRuleContext(CSharpParser.Predefined_typeContext,0)

        def qualified_alias_member(self):
            return self.getTypedRuleContext(CSharpParser.Qualified_alias_memberContext,0)


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

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


    class CheckedExpressionContext(Primary_expression_startContext):

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

        def CHECKED(self):
            return self.getToken(CSharpParser.CHECKED, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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

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


    class LiteralExpressionContext(Primary_expression_startContext):

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

        def literal(self):
            return self.getTypedRuleContext(CSharpParser.LiteralContext,0)


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

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


    class NameofExpressionContext(Primary_expression_startContext):

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

        def NAMEOF(self):
            return self.getToken(CSharpParser.NAMEOF, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

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

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

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



    def primary_expression_start(self):

        localctx = CSharpParser.Primary_expression_startContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_primary_expression_start)
        self._la = 0 # Token type
        try:
            self.state = 916
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                localctx = CSharpParser.LiteralExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 795
                self.literal()
                pass

            elif la_ == 2:
                localctx = CSharpParser.SimpleNameExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 796
                self.identifier()
                self.state = 798
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
                if la_ == 1:
                    self.state = 797
                    self.type_argument_list()


                pass

            elif la_ == 3:
                localctx = CSharpParser.ParenthesisExpressionsContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 800
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 801
                self.expression()
                self.state = 802
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 4:
                localctx = CSharpParser.MemberAccessExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 804
                self.predefined_type()
                pass

            elif la_ == 5:
                localctx = CSharpParser.MemberAccessExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 805
                self.qualified_alias_member()
                pass

            elif la_ == 6:
                localctx = CSharpParser.LiteralAccessExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 806
                self.match(CSharpParser.LITERAL_ACCESS)
                pass

            elif la_ == 7:
                localctx = CSharpParser.ThisReferenceExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 807
                self.match(CSharpParser.THIS)
                pass

            elif la_ == 8:
                localctx = CSharpParser.BaseAccessExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 808
                self.match(CSharpParser.BASE)
                self.state = 818
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.DOT]:
                    self.state = 809
                    self.match(CSharpParser.DOT)
                    self.state = 810
                    self.identifier()
                    self.state = 812
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
                    if la_ == 1:
                        self.state = 811
                        self.type_argument_list()


                    pass
                elif token in [CSharpParser.OPEN_BRACKET]:
                    self.state = 814
                    self.match(CSharpParser.OPEN_BRACKET)
                    self.state = 815
                    self.expression_list()
                    self.state = 816
                    self.match(CSharpParser.CLOSE_BRACKET)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                localctx = CSharpParser.ObjectCreationExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 820
                self.match(CSharpParser.NEW)
                self.state = 849
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:
                    self.state = 821
                    self.type_()
                    self.state = 843
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
                    if la_ == 1:
                        self.state = 822
                        self.object_creation_expression()
                        pass

                    elif la_ == 2:
                        self.state = 823
                        self.object_or_collection_initializer()
                        pass

                    elif la_ == 3:
                        self.state = 824
                        self.match(CSharpParser.OPEN_BRACKET)
                        self.state = 825
                        self.expression_list()
                        self.state = 826
                        self.match(CSharpParser.CLOSE_BRACKET)
                        self.state = 830
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
                        while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                            if _alt==1:
                                self.state = 827
                                self.rank_specifier() 
                            self.state = 832
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

                        self.state = 834
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
                        if la_ == 1:
                            self.state = 833
                            self.array_initializer()


                        pass

                    elif la_ == 4:
                        self.state = 837 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 836
                            self.rank_specifier()
                            self.state = 839 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not (_la==CSharpParser.OPEN_BRACKET):
                                break

                        self.state = 841
                        self.array_initializer()
                        pass


                    pass
                elif token in [CSharpParser.OPEN_BRACE]:
                    self.state = 845
                    self.anonymous_object_initializer()
                    pass
                elif token in [CSharpParser.OPEN_BRACKET]:
                    self.state = 846
                    self.rank_specifier()
                    self.state = 847
                    self.array_initializer()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 10:
                localctx = CSharpParser.TupleExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 851
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 852
                self.argument()
                self.state = 855 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 853
                    self.match(CSharpParser.COMMA)
                    self.state = 854
                    self.argument()
                    self.state = 857 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==CSharpParser.COMMA):
                        break

                self.state = 859
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 11:
                localctx = CSharpParser.TypeofExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 861
                self.match(CSharpParser.TYPEOF)
                self.state = 862
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 866
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,67,self._ctx)
                if la_ == 1:
                    self.state = 863
                    self.unbound_type_name()
                    pass

                elif la_ == 2:
                    self.state = 864
                    self.type_()
                    pass

                elif la_ == 3:
                    self.state = 865
                    self.match(CSharpParser.VOID)
                    pass


                self.state = 868
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 12:
                localctx = CSharpParser.CheckedExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 869
                self.match(CSharpParser.CHECKED)
                self.state = 870
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 871
                self.expression()
                self.state = 872
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 13:
                localctx = CSharpParser.UncheckedExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 874
                self.match(CSharpParser.UNCHECKED)
                self.state = 875
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 876
                self.expression()
                self.state = 877
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 14:
                localctx = CSharpParser.DefaultValueExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 879
                self.match(CSharpParser.DEFAULT)
                self.state = 884
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
                if la_ == 1:
                    self.state = 880
                    self.match(CSharpParser.OPEN_PARENS)
                    self.state = 881
                    self.type_()
                    self.state = 882
                    self.match(CSharpParser.CLOSE_PARENS)


                pass

            elif la_ == 15:
                localctx = CSharpParser.AnonymousMethodExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 887
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.ASYNC:
                    self.state = 886
                    self.match(CSharpParser.ASYNC)


                self.state = 889
                self.match(CSharpParser.DELEGATE)
                self.state = 895
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.OPEN_PARENS:
                    self.state = 890
                    self.match(CSharpParser.OPEN_PARENS)
                    self.state = 892
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CSharpParser.PARTIAL - 75)) | (1 << (CSharpParser.REF - 75)) | (1 << (CSharpParser.REMOVE - 75)) | (1 << (CSharpParser.SBYTE - 75)) | (1 << (CSharpParser.SELECT - 75)) | (1 << (CSharpParser.SET - 75)) | (1 << (CSharpParser.SHORT - 75)) | (1 << (CSharpParser.STRING - 75)) | (1 << (CSharpParser.UINT - 75)) | (1 << (CSharpParser.ULONG - 75)) | (1 << (CSharpParser.UNMANAGED - 75)) | (1 << (CSharpParser.USHORT - 75)) | (1 << (CSharpParser.VAR - 75)) | (1 << (CSharpParser.VOID - 75)) | (1 << (CSharpParser.WHEN - 75)) | (1 << (CSharpParser.WHERE - 75)) | (1 << (CSharpParser.YIELD - 75)) | (1 << (CSharpParser.IDENTIFIER - 75)) | (1 << (CSharpParser.OPEN_PARENS - 75)))) != 0):
                        self.state = 891
                        self.explicit_anonymous_function_parameter_list()


                    self.state = 894
                    self.match(CSharpParser.CLOSE_PARENS)


                self.state = 897
                self.block()
                pass

            elif la_ == 16:
                localctx = CSharpParser.SizeofExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 898
                self.match(CSharpParser.SIZEOF)
                self.state = 899
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 900
                self.type_()
                self.state = 901
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 17:
                localctx = CSharpParser.NameofExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 903
                self.match(CSharpParser.NAMEOF)
                self.state = 904
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 910
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,72,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 905
                        self.identifier()
                        self.state = 906
                        self.match(CSharpParser.DOT) 
                    self.state = 912
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,72,self._ctx)

                self.state = 913
                self.identifier()
                self.state = 914
                self.match(CSharpParser.CLOSE_PARENS)
                pass


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


    class Throwable_expressionContext(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(CSharpParser.ExpressionContext,0)


        def throw_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throw_expressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_throwable_expression

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

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




    def throwable_expression(self):

        localctx = CSharpParser.Throwable_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_throwable_expression)
        try:
            self.state = 920
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 918
                self.expression()
                pass
            elif token in [CSharpParser.THROW]:
                self.enterOuterAlt(localctx, 2)
                self.state = 919
                self.throw_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 Throw_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def THROW(self):
            return self.getToken(CSharpParser.THROW, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_throw_expression

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

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




    def throw_expression(self):

        localctx = CSharpParser.Throw_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_throw_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 922
            self.match(CSharpParser.THROW)
            self.state = 923
            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 Member_accessContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def INTERR(self):
            return self.getToken(CSharpParser.INTERR, 0)

        def type_argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_member_access

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

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




    def member_access(self):

        localctx = CSharpParser.Member_accessContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_member_access)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 926
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.INTERR:
                self.state = 925
                self.match(CSharpParser.INTERR)


            self.state = 928
            self.match(CSharpParser.DOT)
            self.state = 929
            self.identifier()
            self.state = 931
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 930
                self.type_argument_list()


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


    class Bracket_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def indexer_argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Indexer_argumentContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Indexer_argumentContext,i)


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

        def INTERR(self):
            return self.getToken(CSharpParser.INTERR, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_bracket_expression

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

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




    def bracket_expression(self):

        localctx = CSharpParser.Bracket_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_bracket_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 934
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.INTERR:
                self.state = 933
                self.match(CSharpParser.INTERR)


            self.state = 936
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 937
            self.indexer_argument()
            self.state = 942
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 938
                self.match(CSharpParser.COMMA)
                self.state = 939
                self.indexer_argument()
                self.state = 944
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 945
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Indexer_argumentContext(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(CSharpParser.ExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_indexer_argument

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

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




    def indexer_argument(self):

        localctx = CSharpParser.Indexer_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_indexer_argument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 950
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 947
                self.identifier()
                self.state = 948
                self.match(CSharpParser.COLON)


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

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

        def BOOL(self):
            return self.getToken(CSharpParser.BOOL, 0)

        def BYTE(self):
            return self.getToken(CSharpParser.BYTE, 0)

        def CHAR(self):
            return self.getToken(CSharpParser.CHAR, 0)

        def DECIMAL(self):
            return self.getToken(CSharpParser.DECIMAL, 0)

        def DOUBLE(self):
            return self.getToken(CSharpParser.DOUBLE, 0)

        def FLOAT(self):
            return self.getToken(CSharpParser.FLOAT, 0)

        def INT(self):
            return self.getToken(CSharpParser.INT, 0)

        def LONG(self):
            return self.getToken(CSharpParser.LONG, 0)

        def OBJECT(self):
            return self.getToken(CSharpParser.OBJECT, 0)

        def SBYTE(self):
            return self.getToken(CSharpParser.SBYTE, 0)

        def SHORT(self):
            return self.getToken(CSharpParser.SHORT, 0)

        def STRING(self):
            return self.getToken(CSharpParser.STRING, 0)

        def UINT(self):
            return self.getToken(CSharpParser.UINT, 0)

        def ULONG(self):
            return self.getToken(CSharpParser.ULONG, 0)

        def USHORT(self):
            return self.getToken(CSharpParser.USHORT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_predefined_type

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

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




    def predefined_type(self):

        localctx = CSharpParser.Predefined_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_predefined_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 954
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.BOOL) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.INT) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CSharpParser.OBJECT - 68)) | (1 << (CSharpParser.SBYTE - 68)) | (1 << (CSharpParser.SHORT - 68)) | (1 << (CSharpParser.STRING - 68)) | (1 << (CSharpParser.UINT - 68)) | (1 << (CSharpParser.ULONG - 68)) | (1 << (CSharpParser.USHORT - 68)))) != 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 Expression_listContext(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(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_expression_list

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

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




    def expression_list(self):

        localctx = CSharpParser.Expression_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_expression_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 956
            self.expression()
            self.state = 961
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 957
                self.match(CSharpParser.COMMA)
                self.state = 958
                self.expression()
                self.state = 963
                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 Object_or_collection_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def object_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Object_initializerContext,0)


        def collection_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Collection_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_object_or_collection_initializer

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

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




    def object_or_collection_initializer(self):

        localctx = CSharpParser.Object_or_collection_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_object_or_collection_initializer)
        try:
            self.state = 966
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 964
                self.object_initializer()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 965
                self.collection_initializer()
                pass


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


    class Object_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def member_initializer_list(self):
            return self.getTypedRuleContext(CSharpParser.Member_initializer_listContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_object_initializer

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

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




    def object_initializer(self):

        localctx = CSharpParser.Object_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_object_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 968
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 973
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.OPEN_BRACKET - 64)))) != 0):
                self.state = 969
                self.member_initializer_list()
                self.state = 971
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 970
                    self.match(CSharpParser.COMMA)




            self.state = 975
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Member_initializer_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def member_initializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Member_initializerContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Member_initializerContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_member_initializer_list

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

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




    def member_initializer_list(self):

        localctx = CSharpParser.Member_initializer_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_member_initializer_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 977
            self.member_initializer()
            self.state = 982
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,84,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 978
                    self.match(CSharpParser.COMMA)
                    self.state = 979
                    self.member_initializer() 
                self.state = 984
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,84,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 Member_initializerContext(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.getToken(CSharpParser.ASSIGNMENT, 0)

        def initializer_value(self):
            return self.getTypedRuleContext(CSharpParser.Initializer_valueContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_member_initializer

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

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




    def member_initializer(self):

        localctx = CSharpParser.Member_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_member_initializer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 990
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.state = 985
                self.identifier()
                pass
            elif token in [CSharpParser.OPEN_BRACKET]:
                self.state = 986
                self.match(CSharpParser.OPEN_BRACKET)
                self.state = 987
                self.expression()
                self.state = 988
                self.match(CSharpParser.CLOSE_BRACKET)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 992
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 993
            self.initializer_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Initializer_valueContext(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(CSharpParser.ExpressionContext,0)


        def object_or_collection_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_initializer_value

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

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




    def initializer_value(self):

        localctx = CSharpParser.Initializer_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_initializer_value)
        try:
            self.state = 997
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 995
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 996
                self.object_or_collection_initializer()
                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 Collection_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def element_initializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Element_initializerContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Element_initializerContext,i)


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_collection_initializer

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

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




    def collection_initializer(self):

        localctx = CSharpParser.Collection_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_collection_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 999
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1000
            self.element_initializer()
            self.state = 1005
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,87,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1001
                    self.match(CSharpParser.COMMA)
                    self.state = 1002
                    self.element_initializer() 
                self.state = 1007
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,87,self._ctx)

            self.state = 1009
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 1008
                self.match(CSharpParser.COMMA)


            self.state = 1011
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Element_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def non_assignment_expression(self):
            return self.getTypedRuleContext(CSharpParser.Non_assignment_expressionContext,0)


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

        def expression_list(self):
            return self.getTypedRuleContext(CSharpParser.Expression_listContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_element_initializer

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

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




    def element_initializer(self):

        localctx = CSharpParser.Element_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_element_initializer)
        try:
            self.state = 1018
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1013
                self.non_assignment_expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1014
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 1015
                self.expression_list()
                self.state = 1016
                self.match(CSharpParser.CLOSE_BRACE)
                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 Anonymous_object_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def member_declarator_list(self):
            return self.getTypedRuleContext(CSharpParser.Member_declarator_listContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_anonymous_object_initializer

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

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




    def anonymous_object_initializer(self):

        localctx = CSharpParser.Anonymous_object_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_anonymous_object_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1020
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1025
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BASE - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.CHECKED - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DEFAULT - 10)) | (1 << (CSharpParser.DELEGATE - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FALSE - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.NEW - 10)) | (1 << (CSharpParser.NULL_ - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CSharpParser.PARTIAL - 75)) | (1 << (CSharpParser.REMOVE - 75)) | (1 << (CSharpParser.SBYTE - 75)) | (1 << (CSharpParser.SELECT - 75)) | (1 << (CSharpParser.SET - 75)) | (1 << (CSharpParser.SHORT - 75)) | (1 << (CSharpParser.SIZEOF - 75)) | (1 << (CSharpParser.STRING - 75)) | (1 << (CSharpParser.THIS - 75)) | (1 << (CSharpParser.TRUE - 75)) | (1 << (CSharpParser.TYPEOF - 75)) | (1 << (CSharpParser.UINT - 75)) | (1 << (CSharpParser.ULONG - 75)) | (1 << (CSharpParser.UNCHECKED - 75)) | (1 << (CSharpParser.UNMANAGED - 75)) | (1 << (CSharpParser.USHORT - 75)) | (1 << (CSharpParser.VAR - 75)) | (1 << (CSharpParser.WHEN - 75)) | (1 << (CSharpParser.WHERE - 75)) | (1 << (CSharpParser.YIELD - 75)) | (1 << (CSharpParser.IDENTIFIER - 75)) | (1 << (CSharpParser.LITERAL_ACCESS - 75)) | (1 << (CSharpParser.INTEGER_LITERAL - 75)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 75)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 75)) | (1 << (CSharpParser.REAL_LITERAL - 75)) | (1 << (CSharpParser.CHARACTER_LITERAL - 75)) | (1 << (CSharpParser.REGULAR_STRING - 75)) | (1 << (CSharpParser.VERBATIUM_STRING - 75)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 75)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 75)) | (1 << (CSharpParser.OPEN_PARENS - 75)))) != 0):
                self.state = 1021
                self.member_declarator_list()
                self.state = 1023
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1022
                    self.match(CSharpParser.COMMA)




            self.state = 1027
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Member_declarator_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def member_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Member_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Member_declaratorContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_member_declarator_list

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

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




    def member_declarator_list(self):

        localctx = CSharpParser.Member_declarator_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_member_declarator_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1029
            self.member_declarator()
            self.state = 1034
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,92,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1030
                    self.match(CSharpParser.COMMA)
                    self.state = 1031
                    self.member_declarator() 
                self.state = 1036
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,92,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 Member_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def primary_expression(self):
            return self.getTypedRuleContext(CSharpParser.Primary_expressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_member_declarator

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

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




    def member_declarator(self):

        localctx = CSharpParser.Member_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_member_declarator)
        try:
            self.state = 1042
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1037
                self.primary_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1038
                self.identifier()
                self.state = 1039
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1040
                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 Unbound_type_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def DOUBLE_COLON(self):
            return self.getToken(CSharpParser.DOUBLE_COLON, 0)

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

        def generic_dimension_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Generic_dimension_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Generic_dimension_specifierContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_unbound_type_name

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

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




    def unbound_type_name(self):

        localctx = CSharpParser.Unbound_type_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_unbound_type_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1044
            self.identifier()
            self.state = 1053
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.CLOSE_PARENS, CSharpParser.DOT, CSharpParser.LT]:
                self.state = 1046
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 1045
                    self.generic_dimension_specifier()


                pass
            elif token in [CSharpParser.DOUBLE_COLON]:
                self.state = 1048
                self.match(CSharpParser.DOUBLE_COLON)
                self.state = 1049
                self.identifier()
                self.state = 1051
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 1050
                    self.generic_dimension_specifier()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 1062
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.DOT:
                self.state = 1055
                self.match(CSharpParser.DOT)
                self.state = 1056
                self.identifier()
                self.state = 1058
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 1057
                    self.generic_dimension_specifier()


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

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

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_generic_dimension_specifier

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

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




    def generic_dimension_specifier(self):

        localctx = CSharpParser.Generic_dimension_specifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_generic_dimension_specifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1065
            self.match(CSharpParser.LT)
            self.state = 1069
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1066
                self.match(CSharpParser.COMMA)
                self.state = 1071
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1072
            self.match(CSharpParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IsTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def base_type(self):
            return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)


        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)


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

        def INTERR(self):
            return self.getToken(CSharpParser.INTERR, 0)

        def isTypePatternArms(self):
            return self.getTypedRuleContext(CSharpParser.IsTypePatternArmsContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_isType

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

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




    def isType(self):

        localctx = CSharpParser.IsTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_isType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1074
            self.base_type()
            self.state = 1079
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,101,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1077
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.OPEN_BRACKET]:
                        self.state = 1075
                        self.rank_specifier()
                        pass
                    elif token in [CSharpParser.STAR]:
                        self.state = 1076
                        self.match(CSharpParser.STAR)
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 1081
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,101,self._ctx)

            self.state = 1083
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
            if la_ == 1:
                self.state = 1082
                self.match(CSharpParser.INTERR)


            self.state = 1086
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,103,self._ctx)
            if la_ == 1:
                self.state = 1085
                self.isTypePatternArms()


            self.state = 1089
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                self.state = 1088
                self.identifier()


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


    class IsTypePatternArmsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def isTypePatternArm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IsTypePatternArmContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IsTypePatternArmContext,i)


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_isTypePatternArms

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

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




    def isTypePatternArms(self):

        localctx = CSharpParser.IsTypePatternArmsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_isTypePatternArms)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1091
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1092
            self.isTypePatternArm()
            self.state = 1097
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1093
                self.match(CSharpParser.COMMA)
                self.state = 1094
                self.isTypePatternArm()
                self.state = 1099
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1100
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IsTypePatternArmContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_isTypePatternArm

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

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




    def isTypePatternArm(self):

        localctx = CSharpParser.IsTypePatternArmContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_isTypePatternArm)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1102
            self.identifier()
            self.state = 1103
            self.match(CSharpParser.COLON)
            self.state = 1104
            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_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def anonymous_function_signature(self):
            return self.getTypedRuleContext(CSharpParser.Anonymous_function_signatureContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def anonymous_function_body(self):
            return self.getTypedRuleContext(CSharpParser.Anonymous_function_bodyContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_lambda_expression

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

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




    def lambda_expression(self):

        localctx = CSharpParser.Lambda_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_lambda_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1107
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,106,self._ctx)
            if la_ == 1:
                self.state = 1106
                self.match(CSharpParser.ASYNC)


            self.state = 1109
            self.anonymous_function_signature()
            self.state = 1110
            self.right_arrow()
            self.state = 1111
            self.anonymous_function_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Anonymous_function_signatureContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def explicit_anonymous_function_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Explicit_anonymous_function_parameter_listContext,0)


        def implicit_anonymous_function_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Implicit_anonymous_function_parameter_listContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_anonymous_function_signature

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

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




    def anonymous_function_signature(self):

        localctx = CSharpParser.Anonymous_function_signatureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_anonymous_function_signature)
        try:
            self.state = 1124
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,107,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1113
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1114
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1115
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1116
                self.explicit_anonymous_function_parameter_list()
                self.state = 1117
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1119
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1120
                self.implicit_anonymous_function_parameter_list()
                self.state = 1121
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1123
                self.identifier()
                pass


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


    class Explicit_anonymous_function_parameter_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def explicit_anonymous_function_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Explicit_anonymous_function_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Explicit_anonymous_function_parameterContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_explicit_anonymous_function_parameter_list

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

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




    def explicit_anonymous_function_parameter_list(self):

        localctx = CSharpParser.Explicit_anonymous_function_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_explicit_anonymous_function_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1126
            self.explicit_anonymous_function_parameter()
            self.state = 1131
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1127
                self.match(CSharpParser.COMMA)
                self.state = 1128
                self.explicit_anonymous_function_parameter()
                self.state = 1133
                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 Explicit_anonymous_function_parameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_explicit_anonymous_function_parameter

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

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




    def explicit_anonymous_function_parameter(self):

        localctx = CSharpParser.Explicit_anonymous_function_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_explicit_anonymous_function_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1135
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)))) != 0):
                self.state = 1134
                localctx.refout = self._input.LT(1)
                _la = self._input.LA(1)
                if not(((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)))) != 0)):
                    localctx.refout = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1137
            self.type_()
            self.state = 1138
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Implicit_anonymous_function_parameter_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_implicit_anonymous_function_parameter_list

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

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




    def implicit_anonymous_function_parameter_list(self):

        localctx = CSharpParser.Implicit_anonymous_function_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_implicit_anonymous_function_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1140
            self.identifier()
            self.state = 1145
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1141
                self.match(CSharpParser.COMMA)
                self.state = 1142
                self.identifier()
                self.state = 1147
                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 Anonymous_function_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


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


        def getRuleIndex(self):
            return CSharpParser.RULE_anonymous_function_body

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

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




    def anonymous_function_body(self):

        localctx = CSharpParser.Anonymous_function_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_anonymous_function_body)
        try:
            self.state = 1150
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1148
                self.throwable_expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1149
                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 Query_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def from_clause(self):
            return self.getTypedRuleContext(CSharpParser.From_clauseContext,0)


        def query_body(self):
            return self.getTypedRuleContext(CSharpParser.Query_bodyContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_query_expression

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

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




    def query_expression(self):

        localctx = CSharpParser.Query_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_query_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1152
            self.from_clause()
            self.state = 1153
            self.query_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class From_clauseContext(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(CSharpParser.FROM, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

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


        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_from_clause

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

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




    def from_clause(self):

        localctx = CSharpParser.From_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_from_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1155
            self.match(CSharpParser.FROM)
            self.state = 1157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
            if la_ == 1:
                self.state = 1156
                self.type_()


            self.state = 1159
            self.identifier()
            self.state = 1160
            self.match(CSharpParser.IN)
            self.state = 1161
            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 Query_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def select_or_group_clause(self):
            return self.getTypedRuleContext(CSharpParser.Select_or_group_clauseContext,0)


        def query_body_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Query_body_clauseContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Query_body_clauseContext,i)


        def query_continuation(self):
            return self.getTypedRuleContext(CSharpParser.Query_continuationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_query_body

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

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




    def query_body(self):

        localctx = CSharpParser.Query_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_query_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1166
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 48)) & ~0x3f) == 0 and ((1 << (_la - 48)) & ((1 << (CSharpParser.FROM - 48)) | (1 << (CSharpParser.JOIN - 48)) | (1 << (CSharpParser.LET - 48)) | (1 << (CSharpParser.ORDERBY - 48)) | (1 << (CSharpParser.WHERE - 48)))) != 0):
                self.state = 1163
                self.query_body_clause()
                self.state = 1168
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1169
            self.select_or_group_clause()
            self.state = 1171
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 1170
                self.query_continuation()


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


    class Query_body_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def from_clause(self):
            return self.getTypedRuleContext(CSharpParser.From_clauseContext,0)


        def let_clause(self):
            return self.getTypedRuleContext(CSharpParser.Let_clauseContext,0)


        def where_clause(self):
            return self.getTypedRuleContext(CSharpParser.Where_clauseContext,0)


        def combined_join_clause(self):
            return self.getTypedRuleContext(CSharpParser.Combined_join_clauseContext,0)


        def orderby_clause(self):
            return self.getTypedRuleContext(CSharpParser.Orderby_clauseContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_query_body_clause

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

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




    def query_body_clause(self):

        localctx = CSharpParser.Query_body_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_query_body_clause)
        try:
            self.state = 1178
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.FROM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1173
                self.from_clause()
                pass
            elif token in [CSharpParser.LET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1174
                self.let_clause()
                pass
            elif token in [CSharpParser.WHERE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1175
                self.where_clause()
                pass
            elif token in [CSharpParser.JOIN]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1176
                self.combined_join_clause()
                pass
            elif token in [CSharpParser.ORDERBY]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1177
                self.orderby_clause()
                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 Let_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LET(self):
            return self.getToken(CSharpParser.LET, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_let_clause

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

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




    def let_clause(self):

        localctx = CSharpParser.Let_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_let_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1180
            self.match(CSharpParser.LET)
            self.state = 1181
            self.identifier()
            self.state = 1182
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 1183
            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 Where_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHERE(self):
            return self.getToken(CSharpParser.WHERE, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_where_clause

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

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




    def where_clause(self):

        localctx = CSharpParser.Where_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_where_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1185
            self.match(CSharpParser.WHERE)
            self.state = 1186
            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 Combined_join_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def JOIN(self):
            return self.getToken(CSharpParser.JOIN, 0)

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


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

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


        def ON(self):
            return self.getToken(CSharpParser.ON, 0)

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

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def INTO(self):
            return self.getToken(CSharpParser.INTO, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_combined_join_clause

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

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




    def combined_join_clause(self):

        localctx = CSharpParser.Combined_join_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_combined_join_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1188
            self.match(CSharpParser.JOIN)
            self.state = 1190
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
            if la_ == 1:
                self.state = 1189
                self.type_()


            self.state = 1192
            self.identifier()
            self.state = 1193
            self.match(CSharpParser.IN)
            self.state = 1194
            self.expression()
            self.state = 1195
            self.match(CSharpParser.ON)
            self.state = 1196
            self.expression()
            self.state = 1197
            self.match(CSharpParser.EQUALS)
            self.state = 1198
            self.expression()
            self.state = 1201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.INTO:
                self.state = 1199
                self.match(CSharpParser.INTO)
                self.state = 1200
                self.identifier()


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


    class Orderby_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ORDERBY(self):
            return self.getToken(CSharpParser.ORDERBY, 0)

        def ordering(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.OrderingContext)
            else:
                return self.getTypedRuleContext(CSharpParser.OrderingContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_orderby_clause

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

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




    def orderby_clause(self):

        localctx = CSharpParser.Orderby_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_orderby_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1203
            self.match(CSharpParser.ORDERBY)
            self.state = 1204
            self.ordering()
            self.state = 1209
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1205
                self.match(CSharpParser.COMMA)
                self.state = 1206
                self.ordering()
                self.state = 1211
                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 OrderingContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def ASCENDING(self):
            return self.getToken(CSharpParser.ASCENDING, 0)

        def DESCENDING(self):
            return self.getToken(CSharpParser.DESCENDING, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_ordering

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

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




    def ordering(self):

        localctx = CSharpParser.OrderingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_ordering)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1212
            self.expression()
            self.state = 1214
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASCENDING or _la==CSharpParser.DESCENDING:
                self.state = 1213
                localctx.dir_ = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==CSharpParser.ASCENDING or _la==CSharpParser.DESCENDING):
                    localctx.dir_ = 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 Select_or_group_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SELECT(self):
            return self.getToken(CSharpParser.SELECT, 0)

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


        def GROUP(self):
            return self.getToken(CSharpParser.GROUP, 0)

        def BY(self):
            return self.getToken(CSharpParser.BY, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_select_or_group_clause

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

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




    def select_or_group_clause(self):

        localctx = CSharpParser.Select_or_group_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_select_or_group_clause)
        try:
            self.state = 1223
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.SELECT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1216
                self.match(CSharpParser.SELECT)
                self.state = 1217
                self.expression()
                pass
            elif token in [CSharpParser.GROUP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1218
                self.match(CSharpParser.GROUP)
                self.state = 1219
                self.expression()
                self.state = 1220
                self.match(CSharpParser.BY)
                self.state = 1221
                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 Query_continuationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INTO(self):
            return self.getToken(CSharpParser.INTO, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def query_body(self):
            return self.getTypedRuleContext(CSharpParser.Query_bodyContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_query_continuation

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

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




    def query_continuation(self):

        localctx = CSharpParser.Query_continuationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_query_continuation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1225
            self.match(CSharpParser.INTO)
            self.state = 1226
            self.identifier()
            self.state = 1227
            self.query_body()
        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 labeled_Statement(self):
            return self.getTypedRuleContext(CSharpParser.Labeled_StatementContext,0)


        def declarationStatement(self):
            return self.getTypedRuleContext(CSharpParser.DeclarationStatementContext,0)


        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_statement

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

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




    def statement(self):

        localctx = CSharpParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_statement)
        try:
            self.state = 1232
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,121,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1229
                self.labeled_Statement()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1230
                self.declarationStatement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1231
                self.embedded_statement()
                pass


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


    class DeclarationStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def local_variable_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def local_constant_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_constant_declarationContext,0)


        def local_function_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_function_declarationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_declarationStatement

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

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




    def declarationStatement(self):

        localctx = CSharpParser.DeclarationStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_declarationStatement)
        try:
            self.state = 1241
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1234
                self.local_variable_declaration()
                self.state = 1235
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1237
                self.local_constant_declaration()
                self.state = 1238
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1240
                self.local_function_declaration()
                pass


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


    class Local_function_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def local_function_header(self):
            return self.getTypedRuleContext(CSharpParser.Local_function_headerContext,0)


        def local_function_body(self):
            return self.getTypedRuleContext(CSharpParser.Local_function_bodyContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_function_declaration

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

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




    def local_function_declaration(self):

        localctx = CSharpParser.Local_function_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_local_function_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1243
            self.local_function_header()
            self.state = 1244
            self.local_function_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Local_function_headerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def return_type(self):
            return self.getTypedRuleContext(CSharpParser.Return_typeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def local_function_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.Local_function_modifiersContext,0)


        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_function_header

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

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




    def local_function_header(self):

        localctx = CSharpParser.Local_function_headerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_local_function_header)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1247
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,123,self._ctx)
            if la_ == 1:
                self.state = 1246
                self.local_function_modifiers()


            self.state = 1249
            self.return_type()
            self.state = 1250
            self.identifier()
            self.state = 1252
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 1251
                self.type_parameter_list()


            self.state = 1254
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1256
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (CSharpParser.PARAMS - 74)) | (1 << (CSharpParser.PARTIAL - 74)) | (1 << (CSharpParser.REF - 74)) | (1 << (CSharpParser.REMOVE - 74)) | (1 << (CSharpParser.SBYTE - 74)) | (1 << (CSharpParser.SELECT - 74)) | (1 << (CSharpParser.SET - 74)) | (1 << (CSharpParser.SHORT - 74)) | (1 << (CSharpParser.STRING - 74)) | (1 << (CSharpParser.THIS - 74)) | (1 << (CSharpParser.UINT - 74)) | (1 << (CSharpParser.ULONG - 74)) | (1 << (CSharpParser.UNMANAGED - 74)) | (1 << (CSharpParser.USHORT - 74)) | (1 << (CSharpParser.VAR - 74)) | (1 << (CSharpParser.VOID - 74)) | (1 << (CSharpParser.WHEN - 74)) | (1 << (CSharpParser.WHERE - 74)) | (1 << (CSharpParser.YIELD - 74)) | (1 << (CSharpParser.IDENTIFIER - 74)) | (1 << (CSharpParser.OPEN_BRACKET - 74)) | (1 << (CSharpParser.OPEN_PARENS - 74)))) != 0):
                self.state = 1255
                self.formal_parameter_list()


            self.state = 1258
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 1260
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 1259
                self.type_parameter_constraints_clauses()


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


    class Local_function_modifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_local_function_modifiers

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

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




    def local_function_modifiers(self):

        localctx = CSharpParser.Local_function_modifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_local_function_modifiers)
        self._la = 0 # Token type
        try:
            self.state = 1268
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ASYNC, CSharpParser.UNSAFE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1262
                _la = self._input.LA(1)
                if not(_la==CSharpParser.ASYNC or _la==CSharpParser.UNSAFE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1264
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.STATIC:
                    self.state = 1263
                    self.match(CSharpParser.STATIC)


                pass
            elif token in [CSharpParser.STATIC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1266
                self.match(CSharpParser.STATIC)
                self.state = 1267
                _la = self._input.LA(1)
                if not(_la==CSharpParser.ASYNC or _la==CSharpParser.UNSAFE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                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 Local_function_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_local_function_body

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

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




    def local_function_body(self):

        localctx = CSharpParser.Local_function_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_local_function_body)
        try:
            self.state = 1275
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1270
                self.block()
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1271
                self.right_arrow()
                self.state = 1272
                self.throwable_expression()
                self.state = 1273
                self.match(CSharpParser.SEMICOLON)
                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 Labeled_StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

        def statement(self):
            return self.getTypedRuleContext(CSharpParser.StatementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_labeled_Statement

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

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




    def labeled_Statement(self):

        localctx = CSharpParser.Labeled_StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_labeled_Statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1277
            self.identifier()
            self.state = 1278
            self.match(CSharpParser.COLON)
            self.state = 1279
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Embedded_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def simple_embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Simple_embedded_statementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_embedded_statement

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

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




    def embedded_statement(self):

        localctx = CSharpParser.Embedded_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_embedded_statement)
        try:
            self.state = 1283
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1281
                self.block()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GOTO, CSharpParser.GROUP, CSharpParser.IF, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.WHILE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.SEMICOLON, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1282
                self.simple_embedded_statement()
                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 Simple_embedded_statementContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CSharpParser.RULE_simple_embedded_statement

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



    class TryStatementContext(Simple_embedded_statementContext):

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

        def TRY(self):
            return self.getToken(CSharpParser.TRY, 0)
        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)

        def catch_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Catch_clausesContext,0)

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


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

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


    class CheckedStatementContext(Simple_embedded_statementContext):

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

        def CHECKED(self):
            return self.getToken(CSharpParser.CHECKED, 0)
        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


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

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


    class ThrowStatementContext(Simple_embedded_statementContext):

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

        def THROW(self):
            return self.getToken(CSharpParser.THROW, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


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

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


    class TheEmptyStatementContext(Simple_embedded_statementContext):

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

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class UnsafeStatementContext(Simple_embedded_statementContext):

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

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)
        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


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

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


    class ForStatementContext(Simple_embedded_statementContext):

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

        def FOR(self):
            return self.getToken(CSharpParser.FOR, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def SEMICOLON(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.SEMICOLON)
            else:
                return self.getToken(CSharpParser.SEMICOLON, i)
        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

        def for_initializer(self):
            return self.getTypedRuleContext(CSharpParser.For_initializerContext,0)

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

        def for_iterator(self):
            return self.getTypedRuleContext(CSharpParser.For_iteratorContext,0)


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

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


    class BreakStatementContext(Simple_embedded_statementContext):

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

        def BREAK(self):
            return self.getToken(CSharpParser.BREAK, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class IfStatementContext(Simple_embedded_statementContext):

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

        def IF(self):
            return self.getToken(CSharpParser.IF, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def if_body(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.If_bodyContext)
            else:
                return self.getTypedRuleContext(CSharpParser.If_bodyContext,i)

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

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

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


    class ReturnStatementContext(Simple_embedded_statementContext):

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

        def RETURN(self):
            return self.getToken(CSharpParser.RETURN, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


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

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


    class GotoStatementContext(Simple_embedded_statementContext):

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

        def GOTO(self):
            return self.getToken(CSharpParser.GOTO, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)
        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

        def CASE(self):
            return self.getToken(CSharpParser.CASE, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)

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

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


    class SwitchStatementContext(Simple_embedded_statementContext):

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

        def SWITCH(self):
            return self.getToken(CSharpParser.SWITCH, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)
        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)
        def switch_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Switch_sectionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Switch_sectionContext,i)


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

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


    class FixedStatementContext(Simple_embedded_statementContext):

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

        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def pointer_type(self):
            return self.getTypedRuleContext(CSharpParser.Pointer_typeContext,0)

        def fixed_pointer_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorsContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)


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

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


    class WhileStatementContext(Simple_embedded_statementContext):

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

        def WHILE(self):
            return self.getToken(CSharpParser.WHILE, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)


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

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


    class DoStatementContext(Simple_embedded_statementContext):

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

        def DO(self):
            return self.getToken(CSharpParser.DO, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

        def WHILE(self):
            return self.getToken(CSharpParser.WHILE, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class ForeachStatementContext(Simple_embedded_statementContext):

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

        def FOREACH(self):
            return self.getToken(CSharpParser.FOREACH, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def local_variable_type(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_typeContext,0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

        def IN(self):
            return self.getToken(CSharpParser.IN, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

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

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

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


    class UncheckedStatementContext(Simple_embedded_statementContext):

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

        def UNCHECKED(self):
            return self.getToken(CSharpParser.UNCHECKED, 0)
        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


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

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


    class ExpressionStatementContext(Simple_embedded_statementContext):

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

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

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class ContinueStatementContext(Simple_embedded_statementContext):

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

        def CONTINUE(self):
            return self.getToken(CSharpParser.CONTINUE, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class UsingStatementContext(Simple_embedded_statementContext):

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

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def resource_acquisition(self):
            return self.getTypedRuleContext(CSharpParser.Resource_acquisitionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)


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

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


    class LockStatementContext(Simple_embedded_statementContext):

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

        def LOCK(self):
            return self.getToken(CSharpParser.LOCK, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)


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

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


    class YieldStatementContext(Simple_embedded_statementContext):

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

        def YIELD(self):
            return self.getToken(CSharpParser.YIELD, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)
        def RETURN(self):
            return self.getToken(CSharpParser.RETURN, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

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

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

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



    def simple_embedded_statement(self):

        localctx = CSharpParser.Simple_embedded_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_simple_embedded_statement)
        self._la = 0 # Token type
        try:
            self.state = 1415
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,143,self._ctx)
            if la_ == 1:
                localctx = CSharpParser.TheEmptyStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1285
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                localctx = CSharpParser.ExpressionStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1286
                self.expression()
                self.state = 1287
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                localctx = CSharpParser.IfStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1289
                self.match(CSharpParser.IF)
                self.state = 1290
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1291
                self.expression()
                self.state = 1292
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1293
                self.if_body()
                self.state = 1296
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,131,self._ctx)
                if la_ == 1:
                    self.state = 1294
                    self.match(CSharpParser.ELSE)
                    self.state = 1295
                    self.if_body()


                pass

            elif la_ == 4:
                localctx = CSharpParser.SwitchStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1298
                self.match(CSharpParser.SWITCH)
                self.state = 1299
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1300
                self.expression()
                self.state = 1301
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1302
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 1306
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.CASE or _la==CSharpParser.DEFAULT:
                    self.state = 1303
                    self.switch_section()
                    self.state = 1308
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1309
                self.match(CSharpParser.CLOSE_BRACE)
                pass

            elif la_ == 5:
                localctx = CSharpParser.WhileStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1311
                self.match(CSharpParser.WHILE)
                self.state = 1312
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1313
                self.expression()
                self.state = 1314
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1315
                self.embedded_statement()
                pass

            elif la_ == 6:
                localctx = CSharpParser.DoStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 1317
                self.match(CSharpParser.DO)
                self.state = 1318
                self.embedded_statement()
                self.state = 1319
                self.match(CSharpParser.WHILE)
                self.state = 1320
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1321
                self.expression()
                self.state = 1322
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1323
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 7:
                localctx = CSharpParser.ForStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 1325
                self.match(CSharpParser.FOR)
                self.state = 1326
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1328
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FIXED) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.USING - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 1327
                    self.for_initializer()


                self.state = 1330
                self.match(CSharpParser.SEMICOLON)
                self.state = 1332
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 1331
                    self.expression()


                self.state = 1334
                self.match(CSharpParser.SEMICOLON)
                self.state = 1336
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 1335
                    self.for_iterator()


                self.state = 1338
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1339
                self.embedded_statement()
                pass

            elif la_ == 8:
                localctx = CSharpParser.ForeachStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 1341
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.AWAIT:
                    self.state = 1340
                    self.match(CSharpParser.AWAIT)


                self.state = 1343
                self.match(CSharpParser.FOREACH)
                self.state = 1344
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1345
                self.local_variable_type()
                self.state = 1346
                self.identifier()
                self.state = 1347
                self.match(CSharpParser.IN)
                self.state = 1348
                self.expression()
                self.state = 1349
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1350
                self.embedded_statement()
                pass

            elif la_ == 9:
                localctx = CSharpParser.BreakStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 1352
                self.match(CSharpParser.BREAK)
                self.state = 1353
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 10:
                localctx = CSharpParser.ContinueStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 1354
                self.match(CSharpParser.CONTINUE)
                self.state = 1355
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 11:
                localctx = CSharpParser.GotoStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 1356
                self.match(CSharpParser.GOTO)
                self.state = 1361
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                    self.state = 1357
                    self.identifier()
                    pass
                elif token in [CSharpParser.CASE]:
                    self.state = 1358
                    self.match(CSharpParser.CASE)
                    self.state = 1359
                    self.expression()
                    pass
                elif token in [CSharpParser.DEFAULT]:
                    self.state = 1360
                    self.match(CSharpParser.DEFAULT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1363
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 12:
                localctx = CSharpParser.ReturnStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 1364
                self.match(CSharpParser.RETURN)
                self.state = 1366
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 1365
                    self.expression()


                self.state = 1368
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 13:
                localctx = CSharpParser.ThrowStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 1369
                self.match(CSharpParser.THROW)
                self.state = 1371
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 1370
                    self.expression()


                self.state = 1373
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 14:
                localctx = CSharpParser.TryStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 1374
                self.match(CSharpParser.TRY)
                self.state = 1375
                self.block()
                self.state = 1381
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.CATCH]:
                    self.state = 1376
                    self.catch_clauses()
                    self.state = 1378
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.FINALLY:
                        self.state = 1377
                        self.finally_clause()


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

                pass

            elif la_ == 15:
                localctx = CSharpParser.CheckedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 1383
                self.match(CSharpParser.CHECKED)
                self.state = 1384
                self.block()
                pass

            elif la_ == 16:
                localctx = CSharpParser.UncheckedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 1385
                self.match(CSharpParser.UNCHECKED)
                self.state = 1386
                self.block()
                pass

            elif la_ == 17:
                localctx = CSharpParser.LockStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 1387
                self.match(CSharpParser.LOCK)
                self.state = 1388
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1389
                self.expression()
                self.state = 1390
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1391
                self.embedded_statement()
                pass

            elif la_ == 18:
                localctx = CSharpParser.UsingStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 1393
                self.match(CSharpParser.USING)
                self.state = 1394
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1395
                self.resource_acquisition()
                self.state = 1396
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1397
                self.embedded_statement()
                pass

            elif la_ == 19:
                localctx = CSharpParser.YieldStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 1399
                self.match(CSharpParser.YIELD)
                self.state = 1403
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.RETURN]:
                    self.state = 1400
                    self.match(CSharpParser.RETURN)
                    self.state = 1401
                    self.expression()
                    pass
                elif token in [CSharpParser.BREAK]:
                    self.state = 1402
                    self.match(CSharpParser.BREAK)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1405
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 20:
                localctx = CSharpParser.UnsafeStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 1406
                self.match(CSharpParser.UNSAFE)
                self.state = 1407
                self.block()
                pass

            elif la_ == 21:
                localctx = CSharpParser.FixedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 1408
                self.match(CSharpParser.FIXED)
                self.state = 1409
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1410
                self.pointer_type()
                self.state = 1411
                self.fixed_pointer_declarators()
                self.state = 1412
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1413
                self.embedded_statement()
                pass


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


    class BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def statement_list(self):
            return self.getTypedRuleContext(CSharpParser.Statement_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_block

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

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




    def block(self):

        localctx = CSharpParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1417
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BREAK) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.CONST) | (1 << CSharpParser.CONTINUE) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DO) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FIXED) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FOR) | (1 << CSharpParser.FOREACH) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GOTO) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IF) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LOCK) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.RETURN - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STATIC - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.SWITCH - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.THROW - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TRY - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.UNSAFE - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.USING - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.WHILE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)) | (1 << (CSharpParser.OPEN_BRACE - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.SEMICOLON - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                self.state = 1418
                self.statement_list()


            self.state = 1421
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Local_variable_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def local_variable_type(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_typeContext,0)


        def local_variable_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Local_variable_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Local_variable_declaratorContext,i)


        def USING(self):
            return self.getToken(CSharpParser.USING, 0)

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

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

        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)

        def pointer_type(self):
            return self.getTypedRuleContext(CSharpParser.Pointer_typeContext,0)


        def fixed_pointer_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_declaration

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

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




    def local_variable_declaration(self):

        localctx = CSharpParser.Local_variable_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_local_variable_declaration)
        self._la = 0 # Token type
        try:
            self.state = 1444
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1427
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,145,self._ctx)
                if la_ == 1:
                    self.state = 1423
                    self.match(CSharpParser.USING)

                elif la_ == 2:
                    self.state = 1424
                    self.match(CSharpParser.REF)

                elif la_ == 3:
                    self.state = 1425
                    self.match(CSharpParser.REF)
                    self.state = 1426
                    self.match(CSharpParser.READONLY)


                self.state = 1429
                self.local_variable_type()
                self.state = 1430
                self.local_variable_declarator()
                self.state = 1437
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.COMMA:
                    self.state = 1431
                    self.match(CSharpParser.COMMA)
                    self.state = 1432
                    self.local_variable_declarator()
                    self.state = 1433
                    if not  this.IsLocalVariableDeclaration() :
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, " this.IsLocalVariableDeclaration() ")
                    self.state = 1439
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [CSharpParser.FIXED]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1440
                self.match(CSharpParser.FIXED)
                self.state = 1441
                self.pointer_type()
                self.state = 1442
                self.fixed_pointer_declarators()
                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 Local_variable_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def VAR(self):
            return self.getToken(CSharpParser.VAR, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_type

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

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




    def local_variable_type(self):

        localctx = CSharpParser.Local_variable_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_local_variable_type)
        try:
            self.state = 1448
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,148,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1446
                self.match(CSharpParser.VAR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1447
                self.type_()
                pass


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


    class Local_variable_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def local_variable_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_initializerContext,0)


        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_declarator

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

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




    def local_variable_declarator(self):

        localctx = CSharpParser.Local_variable_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_local_variable_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1450
            self.identifier()
            self.state = 1456
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,150,self._ctx)
            if la_ == 1:
                self.state = 1451
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1453
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,149,self._ctx)
                if la_ == 1:
                    self.state = 1452
                    self.match(CSharpParser.REF)


                self.state = 1455
                self.local_variable_initializer()


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


    class Local_variable_initializerContext(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(CSharpParser.ExpressionContext,0)


        def array_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)


        def stackalloc_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Stackalloc_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_initializer

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

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




    def local_variable_initializer(self):

        localctx = CSharpParser.Local_variable_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_local_variable_initializer)
        try:
            self.state = 1461
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1458
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1459
                self.array_initializer()
                pass
            elif token in [CSharpParser.STACKALLOC]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1460
                self.stackalloc_initializer()
                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 Local_constant_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONST(self):
            return self.getToken(CSharpParser.CONST, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def constant_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Constant_declaratorsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_constant_declaration

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

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




    def local_constant_declaration(self):

        localctx = CSharpParser.Local_constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_local_constant_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1463
            self.match(CSharpParser.CONST)
            self.state = 1464
            self.type_()
            self.state = 1465
            self.constant_declarators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class If_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def simple_embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Simple_embedded_statementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_if_body

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

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




    def if_body(self):

        localctx = CSharpParser.If_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_if_body)
        try:
            self.state = 1469
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1467
                self.block()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GOTO, CSharpParser.GROUP, CSharpParser.IF, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.WHILE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.SEMICOLON, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1468
                self.simple_embedded_statement()
                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 Switch_sectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement_list(self):
            return self.getTypedRuleContext(CSharpParser.Statement_listContext,0)


        def switch_label(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Switch_labelContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Switch_labelContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_switch_section

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

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




    def switch_section(self):

        localctx = CSharpParser.Switch_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_switch_section)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1472 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1471
                    self.switch_label()

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

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


    class Switch_labelContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


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

        def case_guard(self):
            return self.getTypedRuleContext(CSharpParser.Case_guardContext,0)


        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_switch_label

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

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




    def switch_label(self):

        localctx = CSharpParser.Switch_labelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_switch_label)
        self._la = 0 # Token type
        try:
            self.state = 1487
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.CASE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1478
                self.match(CSharpParser.CASE)
                self.state = 1479
                self.expression()
                self.state = 1481
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.WHEN:
                    self.state = 1480
                    self.case_guard()


                self.state = 1483
                self.match(CSharpParser.COLON)
                pass
            elif token in [CSharpParser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1485
                self.match(CSharpParser.DEFAULT)
                self.state = 1486
                self.match(CSharpParser.COLON)
                pass
            else:
                raise NoViableAltException(self)

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


    class Case_guardContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHEN(self):
            return self.getToken(CSharpParser.WHEN, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_case_guard

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

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




    def case_guard(self):

        localctx = CSharpParser.Case_guardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_case_guard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1489
            self.match(CSharpParser.WHEN)
            self.state = 1490
            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 Statement_listContext(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(CSharpParser.StatementContext)
            else:
                return self.getTypedRuleContext(CSharpParser.StatementContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_statement_list

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

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




    def statement_list(self):

        localctx = CSharpParser.Statement_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_statement_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1493 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1492
                    self.statement()

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

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

        def local_variable_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)


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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_for_initializer

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

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




    def for_initializer(self):

        localctx = CSharpParser.For_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_for_initializer)
        self._la = 0 # Token type
        try:
            self.state = 1506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,158,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1497
                self.local_variable_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1498
                self.expression()
                self.state = 1503
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.COMMA:
                    self.state = 1499
                    self.match(CSharpParser.COMMA)
                    self.state = 1500
                    self.expression()
                    self.state = 1505
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


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


    class For_iteratorContext(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(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_for_iterator

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

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




    def for_iterator(self):

        localctx = CSharpParser.For_iteratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_for_iterator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1508
            self.expression()
            self.state = 1513
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1509
                self.match(CSharpParser.COMMA)
                self.state = 1510
                self.expression()
                self.state = 1515
                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 Catch_clausesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def specific_catch_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Specific_catch_clauseContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Specific_catch_clauseContext,i)


        def general_catch_clause(self):
            return self.getTypedRuleContext(CSharpParser.General_catch_clauseContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_catch_clauses

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

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




    def catch_clauses(self):

        localctx = CSharpParser.Catch_clausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_catch_clauses)
        self._la = 0 # Token type
        try:
            self.state = 1527
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1516
                self.specific_catch_clause()
                self.state = 1520
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,160,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1517
                        self.specific_catch_clause() 
                    self.state = 1522
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,160,self._ctx)

                self.state = 1524
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.CATCH:
                    self.state = 1523
                    self.general_catch_clause()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1526
                self.general_catch_clause()
                pass


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


    class Specific_catch_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CATCH(self):
            return self.getToken(CSharpParser.CATCH, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

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


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def exception_filter(self):
            return self.getTypedRuleContext(CSharpParser.Exception_filterContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_specific_catch_clause

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

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




    def specific_catch_clause(self):

        localctx = CSharpParser.Specific_catch_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_specific_catch_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1529
            self.match(CSharpParser.CATCH)
            self.state = 1530
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1531
            self.class_type()
            self.state = 1533
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)))) != 0):
                self.state = 1532
                self.identifier()


            self.state = 1535
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 1537
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHEN:
                self.state = 1536
                self.exception_filter()


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

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

        def CATCH(self):
            return self.getToken(CSharpParser.CATCH, 0)

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


        def exception_filter(self):
            return self.getTypedRuleContext(CSharpParser.Exception_filterContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_general_catch_clause

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

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




    def general_catch_clause(self):

        localctx = CSharpParser.General_catch_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_general_catch_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1541
            self.match(CSharpParser.CATCH)
            self.state = 1543
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHEN:
                self.state = 1542
                self.exception_filter()


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

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

        def WHEN(self):
            return self.getToken(CSharpParser.WHEN, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

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


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_exception_filter

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

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




    def exception_filter(self):

        localctx = CSharpParser.Exception_filterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_exception_filter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1547
            self.match(CSharpParser.WHEN)
            self.state = 1548
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1549
            self.expression()
            self.state = 1550
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Finally_clauseContext(ParserRuleContext):
        __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(CSharpParser.FINALLY, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_finally_clause

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

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




    def finally_clause(self):

        localctx = CSharpParser.Finally_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_finally_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1552
            self.match(CSharpParser.FINALLY)
            self.state = 1553
            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 Resource_acquisitionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def local_variable_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)


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


        def getRuleIndex(self):
            return CSharpParser.RULE_resource_acquisition

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

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




    def resource_acquisition(self):

        localctx = CSharpParser.Resource_acquisitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_resource_acquisition)
        try:
            self.state = 1557
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1555
                self.local_variable_declaration()
                pass

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

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

        def NAMESPACE(self):
            return self.getToken(CSharpParser.NAMESPACE, 0)

        def namespace_body(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_bodyContext,0)


        def qualified_identifier(self):
            return self.getTypedRuleContext(CSharpParser.Qualified_identifierContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_declaration

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

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




    def namespace_declaration(self):

        localctx = CSharpParser.Namespace_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_namespace_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            self.match(CSharpParser.NAMESPACE)
            self.state = 1560
            localctx.qi = self.qualified_identifier()
            self.state = 1561
            self.namespace_body()
            self.state = 1563
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 1562
                self.match(CSharpParser.SEMICOLON)


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


    class Qualified_identifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_qualified_identifier

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

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




    def qualified_identifier(self):

        localctx = CSharpParser.Qualified_identifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_qualified_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1565
            self.identifier()
            self.state = 1570
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.DOT:
                self.state = 1566
                self.match(CSharpParser.DOT)
                self.state = 1567
                self.identifier()
                self.state = 1572
                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 Namespace_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def extern_alias_directives(self):
            return self.getTypedRuleContext(CSharpParser.Extern_alias_directivesContext,0)


        def using_directives(self):
            return self.getTypedRuleContext(CSharpParser.Using_directivesContext,0)


        def namespace_member_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_body

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

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




    def namespace_body(self):

        localctx = CSharpParser.Namespace_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_namespace_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1573
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1575
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,169,self._ctx)
            if la_ == 1:
                self.state = 1574
                self.extern_alias_directives()


            self.state = 1578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.USING:
                self.state = 1577
                self.using_directives()


            self.state = 1581
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NAMESPACE - 65)) | (1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 0):
                self.state = 1580
                self.namespace_member_declarations()


            self.state = 1583
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Extern_alias_directivesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def extern_alias_directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Extern_alias_directiveContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Extern_alias_directiveContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_extern_alias_directives

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

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




    def extern_alias_directives(self):

        localctx = CSharpParser.Extern_alias_directivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_extern_alias_directives)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1586 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1585
                    self.extern_alias_directive()

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

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

        def EXTERN(self):
            return self.getToken(CSharpParser.EXTERN, 0)

        def ALIAS(self):
            return self.getToken(CSharpParser.ALIAS, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_extern_alias_directive

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

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




    def extern_alias_directive(self):

        localctx = CSharpParser.Extern_alias_directiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_extern_alias_directive)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1590
            self.match(CSharpParser.EXTERN)
            self.state = 1591
            self.match(CSharpParser.ALIAS)
            self.state = 1592
            self.identifier()
            self.state = 1593
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Using_directivesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def using_directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Using_directiveContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Using_directiveContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_using_directives

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

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




    def using_directives(self):

        localctx = CSharpParser.Using_directivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_using_directives)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1596 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1595
                self.using_directive()
                self.state = 1598 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.USING):
                    break

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


    class Using_directiveContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CSharpParser.RULE_using_directive

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



    class UsingAliasDirectiveContext(Using_directiveContext):

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

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)
        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class UsingNamespaceDirectiveContext(Using_directiveContext):

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

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class UsingStaticDirectiveContext(Using_directiveContext):

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

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)
        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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



    def using_directive(self):

        localctx = CSharpParser.Using_directiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_using_directive)
        try:
            self.state = 1615
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
            if la_ == 1:
                localctx = CSharpParser.UsingAliasDirectiveContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1600
                self.match(CSharpParser.USING)
                self.state = 1601
                self.identifier()
                self.state = 1602
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1603
                self.namespace_or_type_name()
                self.state = 1604
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                localctx = CSharpParser.UsingNamespaceDirectiveContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1606
                self.match(CSharpParser.USING)
                self.state = 1607
                self.namespace_or_type_name()
                self.state = 1608
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                localctx = CSharpParser.UsingStaticDirectiveContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1610
                self.match(CSharpParser.USING)
                self.state = 1611
                self.match(CSharpParser.STATIC)
                self.state = 1612
                self.namespace_or_type_name()
                self.state = 1613
                self.match(CSharpParser.SEMICOLON)
                pass


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


    class Namespace_member_declarationsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespace_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_member_declarations

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

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




    def namespace_member_declarations(self):

        localctx = CSharpParser.Namespace_member_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_namespace_member_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1618 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1617
                self.namespace_member_declaration()
                self.state = 1620 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NAMESPACE - 65)) | (1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 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 Namespace_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespace_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_declarationContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Type_declarationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_member_declaration

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

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




    def namespace_member_declaration(self):

        localctx = CSharpParser.Namespace_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_namespace_member_declaration)
        try:
            self.state = 1624
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.NAMESPACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1622
                self.namespace_declaration()
                pass
            elif token in [CSharpParser.ABSTRACT, CSharpParser.ASYNC, CSharpParser.CLASS, CSharpParser.DELEGATE, CSharpParser.ENUM, CSharpParser.EXTERN, CSharpParser.INTERFACE, CSharpParser.INTERNAL, CSharpParser.NEW, CSharpParser.OVERRIDE, CSharpParser.PARTIAL, CSharpParser.PRIVATE, CSharpParser.PROTECTED, CSharpParser.PUBLIC, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.SEALED, CSharpParser.STATIC, CSharpParser.STRUCT, CSharpParser.UNSAFE, CSharpParser.VIRTUAL, CSharpParser.VOLATILE, CSharpParser.OPEN_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1623
                self.type_declaration()
                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_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def class_definition(self):
            return self.getTypedRuleContext(CSharpParser.Class_definitionContext,0)


        def struct_definition(self):
            return self.getTypedRuleContext(CSharpParser.Struct_definitionContext,0)


        def interface_definition(self):
            return self.getTypedRuleContext(CSharpParser.Interface_definitionContext,0)


        def enum_definition(self):
            return self.getTypedRuleContext(CSharpParser.Enum_definitionContext,0)


        def delegate_definition(self):
            return self.getTypedRuleContext(CSharpParser.Delegate_definitionContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def all_member_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_declaration

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

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




    def type_declaration(self):

        localctx = CSharpParser.Type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_type_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1627
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1626
                self.attributes()


            self.state = 1630
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.state = 1629
                self.all_member_modifiers()


            self.state = 1637
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.CLASS]:
                self.state = 1632
                self.class_definition()
                pass
            elif token in [CSharpParser.READONLY, CSharpParser.REF, CSharpParser.STRUCT]:
                self.state = 1633
                self.struct_definition()
                pass
            elif token in [CSharpParser.INTERFACE]:
                self.state = 1634
                self.interface_definition()
                pass
            elif token in [CSharpParser.ENUM]:
                self.state = 1635
                self.enum_definition()
                pass
            elif token in [CSharpParser.DELEGATE]:
                self.state = 1636
                self.delegate_definition()
                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 Qualified_alias_memberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def DOUBLE_COLON(self):
            return self.getToken(CSharpParser.DOUBLE_COLON, 0)

        def type_argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_qualified_alias_member

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

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




    def qualified_alias_member(self):

        localctx = CSharpParser.Qualified_alias_memberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_qualified_alias_member)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1639
            self.identifier()
            self.state = 1640
            self.match(CSharpParser.DOUBLE_COLON)
            self.state = 1641
            self.identifier()
            self.state = 1643
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
            if la_ == 1:
                self.state = 1642
                self.type_argument_list()


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


    class Type_parameter_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def type_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_parameterContext,i)


        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_list

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

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




    def type_parameter_list(self):

        localctx = CSharpParser.Type_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_type_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1645
            self.match(CSharpParser.LT)
            self.state = 1646
            self.type_parameter()
            self.state = 1651
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1647
                self.match(CSharpParser.COMMA)
                self.state = 1648
                self.type_parameter()
                self.state = 1653
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1654
            self.match(CSharpParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter

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

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




    def type_parameter(self):

        localctx = CSharpParser.Type_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_type_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1657
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1656
                self.attributes()


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


    class Class_baseContext(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(CSharpParser.COLON, 0)

        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


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

        def namespace_or_type_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_base

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

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




    def class_base(self):

        localctx = CSharpParser.Class_baseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_class_base)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1661
            self.match(CSharpParser.COLON)
            self.state = 1662
            self.class_type()
            self.state = 1667
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1663
                self.match(CSharpParser.COMMA)
                self.state = 1664
                self.namespace_or_type_name()
                self.state = 1669
                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 Interface_type_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespace_or_type_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_interface_type_list

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

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




    def interface_type_list(self):

        localctx = CSharpParser.Interface_type_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_interface_type_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1670
            self.namespace_or_type_name()
            self.state = 1675
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1671
                self.match(CSharpParser.COMMA)
                self.state = 1672
                self.namespace_or_type_name()
                self.state = 1677
                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 Type_parameter_constraints_clausesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def type_parameter_constraints_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_parameter_constraints_clauseContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clauseContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_constraints_clauses

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

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




    def type_parameter_constraints_clauses(self):

        localctx = CSharpParser.Type_parameter_constraints_clausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_type_parameter_constraints_clauses)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1679 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1678
                self.type_parameter_constraints_clause()
                self.state = 1681 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.WHERE):
                    break

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


    class Type_parameter_constraints_clauseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHERE(self):
            return self.getToken(CSharpParser.WHERE, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


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

        def type_parameter_constraints(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraintsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_constraints_clause

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

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




    def type_parameter_constraints_clause(self):

        localctx = CSharpParser.Type_parameter_constraints_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_type_parameter_constraints_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1683
            self.match(CSharpParser.WHERE)
            self.state = 1684
            self.identifier()
            self.state = 1685
            self.match(CSharpParser.COLON)
            self.state = 1686
            self.type_parameter_constraints()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameter_constraintsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constructor_constraint(self):
            return self.getTypedRuleContext(CSharpParser.Constructor_constraintContext,0)


        def primary_constraint(self):
            return self.getTypedRuleContext(CSharpParser.Primary_constraintContext,0)


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

        def secondary_constraints(self):
            return self.getTypedRuleContext(CSharpParser.Secondary_constraintsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_constraints

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

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




    def type_parameter_constraints(self):

        localctx = CSharpParser.Type_parameter_constraintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_type_parameter_constraints)
        self._la = 0 # Token type
        try:
            self.state = 1698
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.NEW]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1688
                self.constructor_constraint()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.CLASS, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1689
                self.primary_constraint()
                self.state = 1692
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
                if la_ == 1:
                    self.state = 1690
                    self.match(CSharpParser.COMMA)
                    self.state = 1691
                    self.secondary_constraints()


                self.state = 1696
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1694
                    self.match(CSharpParser.COMMA)
                    self.state = 1695
                    self.constructor_constraint()


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

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

        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


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

        def INTERR(self):
            return self.getToken(CSharpParser.INTERR, 0)

        def STRUCT(self):
            return self.getToken(CSharpParser.STRUCT, 0)

        def UNMANAGED(self):
            return self.getToken(CSharpParser.UNMANAGED, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_primary_constraint

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

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




    def primary_constraint(self):

        localctx = CSharpParser.Primary_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_primary_constraint)
        self._la = 0 # Token type
        try:
            self.state = 1707
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1700
                self.class_type()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1701
                self.match(CSharpParser.CLASS)
                self.state = 1703
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.INTERR:
                    self.state = 1702
                    self.match(CSharpParser.INTERR)


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1705
                self.match(CSharpParser.STRUCT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1706
                self.match(CSharpParser.UNMANAGED)
                pass


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


    class Secondary_constraintsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespace_or_type_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_secondary_constraints

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

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




    def secondary_constraints(self):

        localctx = CSharpParser.Secondary_constraintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_secondary_constraints)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1709
            self.namespace_or_type_name()
            self.state = 1714
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,191,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1710
                    self.match(CSharpParser.COMMA)
                    self.state = 1711
                    self.namespace_or_type_name() 
                self.state = 1716
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,191,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 Constructor_constraintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_constructor_constraint

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

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




    def constructor_constraint(self):

        localctx = CSharpParser.Constructor_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_constructor_constraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1717
            self.match(CSharpParser.NEW)
            self.state = 1718
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1719
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def class_member_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Class_member_declarationsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_body

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

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




    def class_body(self):

        localctx = CSharpParser.Class_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_class_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1721
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1723
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.OVERRIDE - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.PRIVATE - 64)) | (1 << (CSharpParser.PROTECTED - 64)) | (1 << (CSharpParser.PUBLIC - 64)) | (1 << (CSharpParser.READONLY - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SEALED - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.STATIC - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.STRUCT - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.UNSAFE - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VIRTUAL - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.VOLATILE - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.OPEN_BRACKET - 64)))) != 0) or _la==CSharpParser.OPEN_PARENS or _la==CSharpParser.TILDE:
                self.state = 1722
                self.class_member_declarations()


            self.state = 1725
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_member_declarationsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def class_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Class_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Class_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_member_declarations

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

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




    def class_member_declarations(self):

        localctx = CSharpParser.Class_member_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_class_member_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1728 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1727
                self.class_member_declaration()
                self.state = 1730 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.OVERRIDE - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.PRIVATE - 64)) | (1 << (CSharpParser.PROTECTED - 64)) | (1 << (CSharpParser.PUBLIC - 64)) | (1 << (CSharpParser.READONLY - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SEALED - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.STATIC - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.STRUCT - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.UNSAFE - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VIRTUAL - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.VOLATILE - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.OPEN_BRACKET - 64)))) != 0) or _la==CSharpParser.OPEN_PARENS or _la==CSharpParser.TILDE):
                    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_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def common_member_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Common_member_declarationContext,0)


        def destructor_definition(self):
            return self.getTypedRuleContext(CSharpParser.Destructor_definitionContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def all_member_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_member_declaration

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

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




    def class_member_declaration(self):

        localctx = CSharpParser.Class_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_class_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1733
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1732
                self.attributes()


            self.state = 1736
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.state = 1735
                self.all_member_modifiers()


            self.state = 1740
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:
                self.state = 1738
                self.common_member_declaration()
                pass
            elif token in [CSharpParser.TILDE]:
                self.state = 1739
                self.destructor_definition()
                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 All_member_modifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def all_member_modifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.All_member_modifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.All_member_modifierContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_all_member_modifiers

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

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




    def all_member_modifiers(self):

        localctx = CSharpParser.All_member_modifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_all_member_modifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1743 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1742
                    self.all_member_modifier()

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

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

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def PUBLIC(self):
            return self.getToken(CSharpParser.PUBLIC, 0)

        def PROTECTED(self):
            return self.getToken(CSharpParser.PROTECTED, 0)

        def INTERNAL(self):
            return self.getToken(CSharpParser.INTERNAL, 0)

        def PRIVATE(self):
            return self.getToken(CSharpParser.PRIVATE, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def VOLATILE(self):
            return self.getToken(CSharpParser.VOLATILE, 0)

        def VIRTUAL(self):
            return self.getToken(CSharpParser.VIRTUAL, 0)

        def SEALED(self):
            return self.getToken(CSharpParser.SEALED, 0)

        def OVERRIDE(self):
            return self.getToken(CSharpParser.OVERRIDE, 0)

        def ABSTRACT(self):
            return self.getToken(CSharpParser.ABSTRACT, 0)

        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def EXTERN(self):
            return self.getToken(CSharpParser.EXTERN, 0)

        def PARTIAL(self):
            return self.getToken(CSharpParser.PARTIAL, 0)

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

        def getRuleIndex(self):
            return CSharpParser.RULE_all_member_modifier

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

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




    def all_member_modifier(self):

        localctx = CSharpParser.All_member_modifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_all_member_modifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1747
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (CSharpParser.NEW - 66)) | (1 << (CSharpParser.OVERRIDE - 66)) | (1 << (CSharpParser.PARTIAL - 66)) | (1 << (CSharpParser.PRIVATE - 66)) | (1 << (CSharpParser.PROTECTED - 66)) | (1 << (CSharpParser.PUBLIC - 66)) | (1 << (CSharpParser.READONLY - 66)) | (1 << (CSharpParser.SEALED - 66)) | (1 << (CSharpParser.STATIC - 66)) | (1 << (CSharpParser.UNSAFE - 66)) | (1 << (CSharpParser.VIRTUAL - 66)) | (1 << (CSharpParser.VOLATILE - 66)))) != 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 Common_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constant_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Constant_declarationContext,0)


        def typed_member_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Typed_member_declarationContext,0)


        def event_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Event_declarationContext,0)


        def conversion_operator_declarator(self):
            return self.getTypedRuleContext(CSharpParser.Conversion_operator_declaratorContext,0)


        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def constructor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Constructor_declarationContext,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def method_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Method_declarationContext,0)


        def class_definition(self):
            return self.getTypedRuleContext(CSharpParser.Class_definitionContext,0)


        def struct_definition(self):
            return self.getTypedRuleContext(CSharpParser.Struct_definitionContext,0)


        def interface_definition(self):
            return self.getTypedRuleContext(CSharpParser.Interface_definitionContext,0)


        def enum_definition(self):
            return self.getTypedRuleContext(CSharpParser.Enum_definitionContext,0)


        def delegate_definition(self):
            return self.getTypedRuleContext(CSharpParser.Delegate_definitionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_common_member_declaration

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

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




    def common_member_declaration(self):

        localctx = CSharpParser.Common_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_common_member_declaration)
        try:
            self.state = 1768
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,199,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1749
                self.constant_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1750
                self.typed_member_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1751
                self.event_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1752
                self.conversion_operator_declarator()
                self.state = 1758
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:
                    self.state = 1753
                    self.body()
                    pass
                elif token in [CSharpParser.ASSIGNMENT]:
                    self.state = 1754
                    self.right_arrow()
                    self.state = 1755
                    self.throwable_expression()
                    self.state = 1756
                    self.match(CSharpParser.SEMICOLON)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1760
                self.constructor_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1761
                self.match(CSharpParser.VOID)
                self.state = 1762
                self.method_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1763
                self.class_definition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1764
                self.struct_definition()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1765
                self.interface_definition()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1766
                self.enum_definition()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1767
                self.delegate_definition()
                pass


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


    class Typed_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


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

        def indexer_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Indexer_declarationContext,0)


        def method_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Method_declarationContext,0)


        def property_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Property_declarationContext,0)


        def operator_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Operator_declarationContext,0)


        def field_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Field_declarationContext,0)


        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_typed_member_declaration

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

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




    def typed_member_declaration(self):

        localctx = CSharpParser.Typed_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_typed_member_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
            if la_ == 1:
                self.state = 1770
                self.match(CSharpParser.REF)

            elif la_ == 2:
                self.state = 1771
                self.match(CSharpParser.READONLY)
                self.state = 1772
                self.match(CSharpParser.REF)

            elif la_ == 3:
                self.state = 1773
                self.match(CSharpParser.REF)
                self.state = 1774
                self.match(CSharpParser.READONLY)


            self.state = 1777
            self.type_()
            self.state = 1787
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
            if la_ == 1:
                self.state = 1778
                self.namespace_or_type_name()
                self.state = 1779
                self.match(CSharpParser.DOT)
                self.state = 1780
                self.indexer_declaration()
                pass

            elif la_ == 2:
                self.state = 1782
                self.method_declaration()
                pass

            elif la_ == 3:
                self.state = 1783
                self.property_declaration()
                pass

            elif la_ == 4:
                self.state = 1784
                self.indexer_declaration()
                pass

            elif la_ == 5:
                self.state = 1785
                self.operator_declaration()
                pass

            elif la_ == 6:
                self.state = 1786
                self.field_declaration()
                pass


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


    class Constant_declaratorsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def constant_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Constant_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Constant_declaratorContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_constant_declarators

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

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




    def constant_declarators(self):

        localctx = CSharpParser.Constant_declaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_constant_declarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1789
            self.constant_declarator()
            self.state = 1794
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1790
                self.match(CSharpParser.COMMA)
                self.state = 1791
                self.constant_declarator()
                self.state = 1796
                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 Constant_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

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


        def getRuleIndex(self):
            return CSharpParser.RULE_constant_declarator

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

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




    def constant_declarator(self):

        localctx = CSharpParser.Constant_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_constant_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1797
            self.identifier()
            self.state = 1798
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 1799
            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 Variable_declaratorsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def variable_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Variable_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Variable_declaratorContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_variable_declarators

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

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




    def variable_declarators(self):

        localctx = CSharpParser.Variable_declaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_variable_declarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1801
            self.variable_declarator()
            self.state = 1806
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1802
                self.match(CSharpParser.COMMA)
                self.state = 1803
                self.variable_declarator()
                self.state = 1808
                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 Variable_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def variable_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_variable_declarator

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

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




    def variable_declarator(self):

        localctx = CSharpParser.Variable_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_variable_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1809
            self.identifier()
            self.state = 1812
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 1810
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1811
                self.variable_initializer()


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


    class Variable_initializerContext(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(CSharpParser.ExpressionContext,0)


        def array_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_variable_initializer

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

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




    def variable_initializer(self):

        localctx = CSharpParser.Variable_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_variable_initializer)
        try:
            self.state = 1816
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1814
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1815
                self.array_initializer()
                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 Return_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_return_type

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

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




    def return_type(self):

        localctx = CSharpParser.Return_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_return_type)
        try:
            self.state = 1820
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1818
                self.type_()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1819
                self.match(CSharpParser.VOID)
                pass


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


    class Member_nameContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_member_name

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

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




    def member_name(self):

        localctx = CSharpParser.Member_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_member_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1822
            self.namespace_or_type_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Method_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_method_body

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

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




    def method_body(self):

        localctx = CSharpParser.Method_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_method_body)
        try:
            self.state = 1826
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1824
                self.block()
                pass
            elif token in [CSharpParser.SEMICOLON]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1825
                self.match(CSharpParser.SEMICOLON)
                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 Formal_parameter_listContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def parameter_array(self):
            return self.getTypedRuleContext(CSharpParser.Parameter_arrayContext,0)


        def fixed_parameters(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_parametersContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_formal_parameter_list

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

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




    def formal_parameter_list(self):

        localctx = CSharpParser.Formal_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_formal_parameter_list)
        self._la = 0 # Token type
        try:
            self.state = 1834
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1828
                self.parameter_array()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1829
                self.fixed_parameters()
                self.state = 1832
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1830
                    self.match(CSharpParser.COMMA)
                    self.state = 1831
                    self.parameter_array()


                pass


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


    class Fixed_parametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def fixed_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Fixed_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Fixed_parameterContext,i)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_parameters

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

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




    def fixed_parameters(self):

        localctx = CSharpParser.Fixed_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_fixed_parameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1836
            self.fixed_parameter()
            self.state = 1841
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,210,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1837
                    self.match(CSharpParser.COMMA)
                    self.state = 1838
                    self.fixed_parameter() 
                self.state = 1843
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,210,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 Fixed_parameterContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def arg_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def parameter_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Parameter_modifierContext,0)


        def ARGLIST(self):
            return self.getToken(CSharpParser.ARGLIST, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_parameter

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

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




    def fixed_parameter(self):

        localctx = CSharpParser.Fixed_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_fixed_parameter)
        self._la = 0 # Token type
        try:
            self.state = 1852
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1845
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.OPEN_BRACKET:
                    self.state = 1844
                    self.attributes()


                self.state = 1848
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)) | (1 << (CSharpParser.THIS - 54)))) != 0):
                    self.state = 1847
                    self.parameter_modifier()


                self.state = 1850
                self.arg_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1851
                self.match(CSharpParser.ARGLIST)
                pass


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


    class Parameter_modifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

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

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_parameter_modifier

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

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




    def parameter_modifier(self):

        localctx = CSharpParser.Parameter_modifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_parameter_modifier)
        try:
            self.state = 1862
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1854
                self.match(CSharpParser.REF)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1855
                self.match(CSharpParser.OUT)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1856
                self.match(CSharpParser.IN)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1857
                self.match(CSharpParser.REF)
                self.state = 1858
                self.match(CSharpParser.THIS)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1859
                self.match(CSharpParser.IN)
                self.state = 1860
                self.match(CSharpParser.THIS)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1861
                self.match(CSharpParser.THIS)
                pass


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


    class Parameter_arrayContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PARAMS(self):
            return self.getToken(CSharpParser.PARAMS, 0)

        def array_type(self):
            return self.getTypedRuleContext(CSharpParser.Array_typeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_parameter_array

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

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




    def parameter_array(self):

        localctx = CSharpParser.Parameter_arrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_parameter_array)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1865
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1864
                self.attributes()


            self.state = 1867
            self.match(CSharpParser.PARAMS)
            self.state = 1868
            self.array_type()
            self.state = 1869
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Accessor_declarationsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.attrs = None # AttributesContext
            self.mods = None # Accessor_modifierContext

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def accessor_body(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)


        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def accessor_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)


        def set_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Set_accessor_declarationContext,0)


        def get_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Get_accessor_declarationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_accessor_declarations

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

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




    def accessor_declarations(self):

        localctx = CSharpParser.Accessor_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_accessor_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1872
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1871
                localctx.attrs = self.attributes()


            self.state = 1875
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 57)) & ~0x3f) == 0 and ((1 << (_la - 57)) & ((1 << (CSharpParser.INTERNAL - 57)) | (1 << (CSharpParser.PRIVATE - 57)) | (1 << (CSharpParser.PROTECTED - 57)))) != 0):
                self.state = 1874
                localctx.mods = self.accessor_modifier()


            self.state = 1887
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.GET]:
                self.state = 1877
                self.match(CSharpParser.GET)
                self.state = 1878
                self.accessor_body()
                self.state = 1880
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.INTERNAL or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CSharpParser.PRIVATE - 76)) | (1 << (CSharpParser.PROTECTED - 76)) | (1 << (CSharpParser.SET - 76)) | (1 << (CSharpParser.OPEN_BRACKET - 76)))) != 0):
                    self.state = 1879
                    self.set_accessor_declaration()


                pass
            elif token in [CSharpParser.SET]:
                self.state = 1882
                self.match(CSharpParser.SET)
                self.state = 1883
                self.accessor_body()
                self.state = 1885
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.GET or _la==CSharpParser.INTERNAL or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CSharpParser.PRIVATE - 76)) | (1 << (CSharpParser.PROTECTED - 76)) | (1 << (CSharpParser.OPEN_BRACKET - 76)))) != 0):
                    self.state = 1884
                    self.get_accessor_declaration()


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

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

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def accessor_body(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def accessor_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_get_accessor_declaration

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

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




    def get_accessor_declaration(self):

        localctx = CSharpParser.Get_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_get_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1890
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1889
                self.attributes()


            self.state = 1893
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 57)) & ~0x3f) == 0 and ((1 << (_la - 57)) & ((1 << (CSharpParser.INTERNAL - 57)) | (1 << (CSharpParser.PRIVATE - 57)) | (1 << (CSharpParser.PROTECTED - 57)))) != 0):
                self.state = 1892
                self.accessor_modifier()


            self.state = 1895
            self.match(CSharpParser.GET)
            self.state = 1896
            self.accessor_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Set_accessor_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def accessor_body(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def accessor_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_set_accessor_declaration

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

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




    def set_accessor_declaration(self):

        localctx = CSharpParser.Set_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_set_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1899
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1898
                self.attributes()


            self.state = 1902
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 57)) & ~0x3f) == 0 and ((1 << (_la - 57)) & ((1 << (CSharpParser.INTERNAL - 57)) | (1 << (CSharpParser.PRIVATE - 57)) | (1 << (CSharpParser.PROTECTED - 57)))) != 0):
                self.state = 1901
                self.accessor_modifier()


            self.state = 1904
            self.match(CSharpParser.SET)
            self.state = 1905
            self.accessor_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Accessor_modifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PROTECTED(self):
            return self.getToken(CSharpParser.PROTECTED, 0)

        def INTERNAL(self):
            return self.getToken(CSharpParser.INTERNAL, 0)

        def PRIVATE(self):
            return self.getToken(CSharpParser.PRIVATE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_accessor_modifier

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

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




    def accessor_modifier(self):

        localctx = CSharpParser.Accessor_modifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_accessor_modifier)
        try:
            self.state = 1914
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1907
                self.match(CSharpParser.PROTECTED)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1908
                self.match(CSharpParser.INTERNAL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1909
                self.match(CSharpParser.PRIVATE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1910
                self.match(CSharpParser.PROTECTED)
                self.state = 1911
                self.match(CSharpParser.INTERNAL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1912
                self.match(CSharpParser.INTERNAL)
                self.state = 1913
                self.match(CSharpParser.PROTECTED)
                pass


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


    class Accessor_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_accessor_body

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

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




    def accessor_body(self):

        localctx = CSharpParser.Accessor_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_accessor_body)
        try:
            self.state = 1918
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1916
                self.block()
                pass
            elif token in [CSharpParser.SEMICOLON]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1917
                self.match(CSharpParser.SEMICOLON)
                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 Event_accessor_declarationsContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def remove_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Remove_accessor_declarationContext,0)


        def REMOVE(self):
            return self.getToken(CSharpParser.REMOVE, 0)

        def add_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Add_accessor_declarationContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_event_accessor_declarations

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

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




    def event_accessor_declarations(self):

        localctx = CSharpParser.Event_accessor_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_event_accessor_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1921
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1920
                self.attributes()


            self.state = 1931
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD]:
                self.state = 1923
                self.match(CSharpParser.ADD)
                self.state = 1924
                self.block()
                self.state = 1925
                self.remove_accessor_declaration()
                pass
            elif token in [CSharpParser.REMOVE]:
                self.state = 1927
                self.match(CSharpParser.REMOVE)
                self.state = 1928
                self.block()
                self.state = 1929
                self.add_accessor_declaration()
                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 Add_accessor_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_add_accessor_declaration

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

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




    def add_accessor_declaration(self):

        localctx = CSharpParser.Add_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_add_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1934
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1933
                self.attributes()


            self.state = 1936
            self.match(CSharpParser.ADD)
            self.state = 1937
            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 Remove_accessor_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def REMOVE(self):
            return self.getToken(CSharpParser.REMOVE, 0)

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


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_remove_accessor_declaration

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

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




    def remove_accessor_declaration(self):

        localctx = CSharpParser.Remove_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_remove_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1940
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1939
                self.attributes()


            self.state = 1942
            self.match(CSharpParser.REMOVE)
            self.state = 1943
            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 Overloadable_operatorContext(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(CSharpParser.PLUS, 0)

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

        def BANG(self):
            return self.getToken(CSharpParser.BANG, 0)

        def TILDE(self):
            return self.getToken(CSharpParser.TILDE, 0)

        def OP_INC(self):
            return self.getToken(CSharpParser.OP_INC, 0)

        def OP_DEC(self):
            return self.getToken(CSharpParser.OP_DEC, 0)

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

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

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

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

        def PERCENT(self):
            return self.getToken(CSharpParser.PERCENT, 0)

        def AMP(self):
            return self.getToken(CSharpParser.AMP, 0)

        def BITWISE_OR(self):
            return self.getToken(CSharpParser.BITWISE_OR, 0)

        def CARET(self):
            return self.getToken(CSharpParser.CARET, 0)

        def OP_LEFT_SHIFT(self):
            return self.getToken(CSharpParser.OP_LEFT_SHIFT, 0)

        def right_shift(self):
            return self.getTypedRuleContext(CSharpParser.Right_shiftContext,0)


        def OP_EQ(self):
            return self.getToken(CSharpParser.OP_EQ, 0)

        def OP_NE(self):
            return self.getToken(CSharpParser.OP_NE, 0)

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def OP_GE(self):
            return self.getToken(CSharpParser.OP_GE, 0)

        def OP_LE(self):
            return self.getToken(CSharpParser.OP_LE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_overloadable_operator

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

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




    def overloadable_operator(self):

        localctx = CSharpParser.Overloadable_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_overloadable_operator)
        try:
            self.state = 1967
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,231,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1945
                self.match(CSharpParser.PLUS)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1946
                self.match(CSharpParser.MINUS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1947
                self.match(CSharpParser.BANG)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1948
                self.match(CSharpParser.TILDE)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1949
                self.match(CSharpParser.OP_INC)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1950
                self.match(CSharpParser.OP_DEC)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1951
                self.match(CSharpParser.TRUE)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1952
                self.match(CSharpParser.FALSE)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1953
                self.match(CSharpParser.STAR)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1954
                self.match(CSharpParser.DIV)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1955
                self.match(CSharpParser.PERCENT)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1956
                self.match(CSharpParser.AMP)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1957
                self.match(CSharpParser.BITWISE_OR)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1958
                self.match(CSharpParser.CARET)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1959
                self.match(CSharpParser.OP_LEFT_SHIFT)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1960
                self.right_shift()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1961
                self.match(CSharpParser.OP_EQ)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1962
                self.match(CSharpParser.OP_NE)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1963
                self.match(CSharpParser.GT)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1964
                self.match(CSharpParser.LT)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1965
                self.match(CSharpParser.OP_GE)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 1966
                self.match(CSharpParser.OP_LE)
                pass


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


    class Conversion_operator_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OPERATOR(self):
            return self.getToken(CSharpParser.OPERATOR, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def arg_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,0)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def IMPLICIT(self):
            return self.getToken(CSharpParser.IMPLICIT, 0)

        def EXPLICIT(self):
            return self.getToken(CSharpParser.EXPLICIT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_conversion_operator_declarator

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

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




    def conversion_operator_declarator(self):

        localctx = CSharpParser.Conversion_operator_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_conversion_operator_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1969
            _la = self._input.LA(1)
            if not(_la==CSharpParser.EXPLICIT or _la==CSharpParser.IMPLICIT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1970
            self.match(CSharpParser.OPERATOR)
            self.state = 1971
            self.type_()
            self.state = 1972
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1973
            self.arg_declaration()
            self.state = 1974
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constructor_initializerContext(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(CSharpParser.COLON, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def BASE(self):
            return self.getToken(CSharpParser.BASE, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_constructor_initializer

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

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




    def constructor_initializer(self):

        localctx = CSharpParser.Constructor_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_constructor_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1976
            self.match(CSharpParser.COLON)
            self.state = 1977
            _la = self._input.LA(1)
            if not(_la==CSharpParser.BASE or _la==CSharpParser.THIS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1978
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1980
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IN) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.OUT - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                self.state = 1979
                self.argument_list()


            self.state = 1982
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_body

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

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




    def body(self):

        localctx = CSharpParser.BodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_body)
        try:
            self.state = 1986
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1984
                self.block()
                pass
            elif token in [CSharpParser.SEMICOLON]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1985
                self.match(CSharpParser.SEMICOLON)
                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 Struct_interfacesContext(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(CSharpParser.COLON, 0)

        def interface_type_list(self):
            return self.getTypedRuleContext(CSharpParser.Interface_type_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_struct_interfaces

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

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




    def struct_interfaces(self):

        localctx = CSharpParser.Struct_interfacesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_struct_interfaces)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1988
            self.match(CSharpParser.COLON)
            self.state = 1989
            self.interface_type_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def struct_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Struct_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Struct_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_struct_body

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

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




    def struct_body(self):

        localctx = CSharpParser.Struct_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_struct_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1991
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1995
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 9)) & ~0x3f) == 0 and ((1 << (_la - 9)) & ((1 << (CSharpParser.ABSTRACT - 9)) | (1 << (CSharpParser.ADD - 9)) | (1 << (CSharpParser.ALIAS - 9)) | (1 << (CSharpParser.ARGLIST - 9)) | (1 << (CSharpParser.ASCENDING - 9)) | (1 << (CSharpParser.ASYNC - 9)) | (1 << (CSharpParser.AWAIT - 9)) | (1 << (CSharpParser.BOOL - 9)) | (1 << (CSharpParser.BY - 9)) | (1 << (CSharpParser.BYTE - 9)) | (1 << (CSharpParser.CHAR - 9)) | (1 << (CSharpParser.CLASS - 9)) | (1 << (CSharpParser.CONST - 9)) | (1 << (CSharpParser.DECIMAL - 9)) | (1 << (CSharpParser.DELEGATE - 9)) | (1 << (CSharpParser.DESCENDING - 9)) | (1 << (CSharpParser.DOUBLE - 9)) | (1 << (CSharpParser.DYNAMIC - 9)) | (1 << (CSharpParser.ENUM - 9)) | (1 << (CSharpParser.EQUALS - 9)) | (1 << (CSharpParser.EVENT - 9)) | (1 << (CSharpParser.EXPLICIT - 9)) | (1 << (CSharpParser.EXTERN - 9)) | (1 << (CSharpParser.FIXED - 9)) | (1 << (CSharpParser.FLOAT - 9)) | (1 << (CSharpParser.FROM - 9)) | (1 << (CSharpParser.GET - 9)) | (1 << (CSharpParser.GROUP - 9)) | (1 << (CSharpParser.IMPLICIT - 9)) | (1 << (CSharpParser.INT - 9)) | (1 << (CSharpParser.INTERFACE - 9)) | (1 << (CSharpParser.INTERNAL - 9)) | (1 << (CSharpParser.INTO - 9)) | (1 << (CSharpParser.JOIN - 9)) | (1 << (CSharpParser.LET - 9)) | (1 << (CSharpParser.LONG - 9)) | (1 << (CSharpParser.NAMEOF - 9)) | (1 << (CSharpParser.NEW - 9)) | (1 << (CSharpParser.OBJECT - 9)) | (1 << (CSharpParser.ON - 9)) | (1 << (CSharpParser.ORDERBY - 9)))) != 0) or ((((_la - 73)) & ~0x3f) == 0 and ((1 << (_la - 73)) & ((1 << (CSharpParser.OVERRIDE - 73)) | (1 << (CSharpParser.PARTIAL - 73)) | (1 << (CSharpParser.PRIVATE - 73)) | (1 << (CSharpParser.PROTECTED - 73)) | (1 << (CSharpParser.PUBLIC - 73)) | (1 << (CSharpParser.READONLY - 73)) | (1 << (CSharpParser.REF - 73)) | (1 << (CSharpParser.REMOVE - 73)) | (1 << (CSharpParser.SBYTE - 73)) | (1 << (CSharpParser.SEALED - 73)) | (1 << (CSharpParser.SELECT - 73)) | (1 << (CSharpParser.SET - 73)) | (1 << (CSharpParser.SHORT - 73)) | (1 << (CSharpParser.STATIC - 73)) | (1 << (CSharpParser.STRING - 73)) | (1 << (CSharpParser.STRUCT - 73)) | (1 << (CSharpParser.UINT - 73)) | (1 << (CSharpParser.ULONG - 73)) | (1 << (CSharpParser.UNMANAGED - 73)) | (1 << (CSharpParser.UNSAFE - 73)) | (1 << (CSharpParser.USHORT - 73)) | (1 << (CSharpParser.VAR - 73)) | (1 << (CSharpParser.VIRTUAL - 73)) | (1 << (CSharpParser.VOID - 73)) | (1 << (CSharpParser.VOLATILE - 73)) | (1 << (CSharpParser.WHEN - 73)) | (1 << (CSharpParser.WHERE - 73)) | (1 << (CSharpParser.YIELD - 73)) | (1 << (CSharpParser.IDENTIFIER - 73)) | (1 << (CSharpParser.OPEN_BRACKET - 73)) | (1 << (CSharpParser.OPEN_PARENS - 73)))) != 0):
                self.state = 1992
                self.struct_member_declaration()
                self.state = 1997
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1998
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def common_member_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Common_member_declarationContext,0)


        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def all_member_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)


        def fixed_size_buffer_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Fixed_size_buffer_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Fixed_size_buffer_declaratorContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_struct_member_declaration

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

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




    def struct_member_declaration(self):

        localctx = CSharpParser.Struct_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_struct_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2001
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 2000
                self.attributes()


            self.state = 2004
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,236,self._ctx)
            if la_ == 1:
                self.state = 2003
                self.all_member_modifiers()


            self.state = 2016
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:
                self.state = 2006
                self.common_member_declaration()
                pass
            elif token in [CSharpParser.FIXED]:
                self.state = 2007
                self.match(CSharpParser.FIXED)
                self.state = 2008
                self.type_()
                self.state = 2010 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2009
                    self.fixed_size_buffer_declarator()
                    self.state = 2012 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)))) != 0)):
                        break

                self.state = 2014
                self.match(CSharpParser.SEMICOLON)
                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 Array_typeContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def base_type(self):
            return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)


        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_array_type

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

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




    def array_type(self):

        localctx = CSharpParser.Array_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_array_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2018
            self.base_type()
            self.state = 2026 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2022
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.STAR or _la==CSharpParser.INTERR:
                    self.state = 2019
                    _la = self._input.LA(1)
                    if not(_la==CSharpParser.STAR or _la==CSharpParser.INTERR):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 2024
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2025
                self.rank_specifier()
                self.state = 2028 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (CSharpParser.OPEN_BRACKET - 127)) | (1 << (CSharpParser.STAR - 127)) | (1 << (CSharpParser.INTERR - 127)))) != 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 Rank_specifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_rank_specifier

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

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




    def rank_specifier(self):

        localctx = CSharpParser.Rank_specifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_rank_specifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2030
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2034
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 2031
                self.match(CSharpParser.COMMA)
                self.state = 2036
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2037
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Array_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def variable_initializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Variable_initializerContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_array_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArray_initializer" ):
                listener.enterArray_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArray_initializer" ):
                listener.exitArray_initializer(self)




    def array_initializer(self):

        localctx = CSharpParser.Array_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_array_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2039
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 2051
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)) | (1 << (CSharpParser.OPEN_BRACE - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                self.state = 2040
                self.variable_initializer()
                self.state = 2045
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,242,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2041
                        self.match(CSharpParser.COMMA)
                        self.state = 2042
                        self.variable_initializer() 
                    self.state = 2047
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,242,self._ctx)

                self.state = 2049
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 2048
                    self.match(CSharpParser.COMMA)




            self.state = 2053
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variant_type_parameter_listContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def variant_type_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Variant_type_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Variant_type_parameterContext,i)


        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_variant_type_parameter_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariant_type_parameter_list" ):
                listener.enterVariant_type_parameter_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariant_type_parameter_list" ):
                listener.exitVariant_type_parameter_list(self)




    def variant_type_parameter_list(self):

        localctx = CSharpParser.Variant_type_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_variant_type_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2055
            self.match(CSharpParser.LT)
            self.state = 2056
            self.variant_type_parameter()
            self.state = 2061
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 2057
                self.match(CSharpParser.COMMA)
                self.state = 2058
                self.variant_type_parameter()
                self.state = 2063
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2064
            self.match(CSharpParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variant_type_parameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def variance_annotation(self):
            return self.getTypedRuleContext(CSharpParser.Variance_annotationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_variant_type_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariant_type_parameter" ):
                listener.enterVariant_type_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariant_type_parameter" ):
                listener.exitVariant_type_parameter(self)




    def variant_type_parameter(self):

        localctx = CSharpParser.Variant_type_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_variant_type_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2067
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 2066
                self.attributes()


            self.state = 2070
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.IN or _la==CSharpParser.OUT:
                self.state = 2069
                self.variance_annotation()


            self.state = 2072
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variance_annotationContext(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(CSharpParser.IN, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_variance_annotation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariance_annotation" ):
                listener.enterVariance_annotation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariance_annotation" ):
                listener.exitVariance_annotation(self)




    def variance_annotation(self):

        localctx = CSharpParser.Variance_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_variance_annotation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2074
            _la = self._input.LA(1)
            if not(_la==CSharpParser.IN or _la==CSharpParser.OUT):
                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 Interface_baseContext(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(CSharpParser.COLON, 0)

        def interface_type_list(self):
            return self.getTypedRuleContext(CSharpParser.Interface_type_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_base

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_base" ):
                listener.enterInterface_base(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_base" ):
                listener.exitInterface_base(self)




    def interface_base(self):

        localctx = CSharpParser.Interface_baseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_interface_base)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2076
            self.match(CSharpParser.COLON)
            self.state = 2077
            self.interface_type_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def interface_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Interface_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Interface_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_body" ):
                listener.enterInterface_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_body" ):
                listener.exitInterface_body(self)




    def interface_body(self):

        localctx = CSharpParser.Interface_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_interface_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2079
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 2083
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.EVENT - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.NEW - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CSharpParser.PARTIAL - 75)) | (1 << (CSharpParser.READONLY - 75)) | (1 << (CSharpParser.REF - 75)) | (1 << (CSharpParser.REMOVE - 75)) | (1 << (CSharpParser.SBYTE - 75)) | (1 << (CSharpParser.SELECT - 75)) | (1 << (CSharpParser.SET - 75)) | (1 << (CSharpParser.SHORT - 75)) | (1 << (CSharpParser.STRING - 75)) | (1 << (CSharpParser.UINT - 75)) | (1 << (CSharpParser.ULONG - 75)) | (1 << (CSharpParser.UNMANAGED - 75)) | (1 << (CSharpParser.UNSAFE - 75)) | (1 << (CSharpParser.USHORT - 75)) | (1 << (CSharpParser.VAR - 75)) | (1 << (CSharpParser.VOID - 75)) | (1 << (CSharpParser.WHEN - 75)) | (1 << (CSharpParser.WHERE - 75)) | (1 << (CSharpParser.YIELD - 75)) | (1 << (CSharpParser.IDENTIFIER - 75)) | (1 << (CSharpParser.OPEN_BRACKET - 75)) | (1 << (CSharpParser.OPEN_PARENS - 75)))) != 0):
                self.state = 2080
                self.interface_member_declaration()
                self.state = 2085
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2086
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def EVENT(self):
            return self.getToken(CSharpParser.EVENT, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def interface_accessors(self):
            return self.getTypedRuleContext(CSharpParser.Interface_accessorsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_member_declaration" ):
                listener.enterInterface_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_member_declaration" ):
                listener.exitInterface_member_declaration(self)




    def interface_member_declaration(self):

        localctx = CSharpParser.Interface_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_interface_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2089
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 2088
                self.attributes()


            self.state = 2092
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.NEW:
                self.state = 2091
                self.match(CSharpParser.NEW)


            self.state = 2157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,261,self._ctx)
            if la_ == 1:
                self.state = 2095
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.UNSAFE:
                    self.state = 2094
                    self.match(CSharpParser.UNSAFE)


                self.state = 2102
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
                if la_ == 1:
                    self.state = 2097
                    self.match(CSharpParser.REF)

                elif la_ == 2:
                    self.state = 2098
                    self.match(CSharpParser.REF)
                    self.state = 2099
                    self.match(CSharpParser.READONLY)

                elif la_ == 3:
                    self.state = 2100
                    self.match(CSharpParser.READONLY)
                    self.state = 2101
                    self.match(CSharpParser.REF)


                self.state = 2104
                self.type_()
                self.state = 2132
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,256,self._ctx)
                if la_ == 1:
                    self.state = 2105
                    self.identifier()
                    self.state = 2107
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.LT:
                        self.state = 2106
                        self.type_parameter_list()


                    self.state = 2109
                    self.match(CSharpParser.OPEN_PARENS)
                    self.state = 2111
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (CSharpParser.PARAMS - 74)) | (1 << (CSharpParser.PARTIAL - 74)) | (1 << (CSharpParser.REF - 74)) | (1 << (CSharpParser.REMOVE - 74)) | (1 << (CSharpParser.SBYTE - 74)) | (1 << (CSharpParser.SELECT - 74)) | (1 << (CSharpParser.SET - 74)) | (1 << (CSharpParser.SHORT - 74)) | (1 << (CSharpParser.STRING - 74)) | (1 << (CSharpParser.THIS - 74)) | (1 << (CSharpParser.UINT - 74)) | (1 << (CSharpParser.ULONG - 74)) | (1 << (CSharpParser.UNMANAGED - 74)) | (1 << (CSharpParser.USHORT - 74)) | (1 << (CSharpParser.VAR - 74)) | (1 << (CSharpParser.VOID - 74)) | (1 << (CSharpParser.WHEN - 74)) | (1 << (CSharpParser.WHERE - 74)) | (1 << (CSharpParser.YIELD - 74)) | (1 << (CSharpParser.IDENTIFIER - 74)) | (1 << (CSharpParser.OPEN_BRACKET - 74)) | (1 << (CSharpParser.OPEN_PARENS - 74)))) != 0):
                        self.state = 2110
                        self.formal_parameter_list()


                    self.state = 2113
                    self.match(CSharpParser.CLOSE_PARENS)
                    self.state = 2115
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.WHERE:
                        self.state = 2114
                        self.type_parameter_constraints_clauses()


                    self.state = 2117
                    self.match(CSharpParser.SEMICOLON)
                    pass

                elif la_ == 2:
                    self.state = 2119
                    self.identifier()
                    self.state = 2120
                    self.match(CSharpParser.OPEN_BRACE)
                    self.state = 2121
                    self.interface_accessors()
                    self.state = 2122
                    self.match(CSharpParser.CLOSE_BRACE)
                    pass

                elif la_ == 3:
                    self.state = 2124
                    self.match(CSharpParser.THIS)
                    self.state = 2125
                    self.match(CSharpParser.OPEN_BRACKET)
                    self.state = 2126
                    self.formal_parameter_list()
                    self.state = 2127
                    self.match(CSharpParser.CLOSE_BRACKET)
                    self.state = 2128
                    self.match(CSharpParser.OPEN_BRACE)
                    self.state = 2129
                    self.interface_accessors()
                    self.state = 2130
                    self.match(CSharpParser.CLOSE_BRACE)
                    pass


                pass

            elif la_ == 2:
                self.state = 2135
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.UNSAFE:
                    self.state = 2134
                    self.match(CSharpParser.UNSAFE)


                self.state = 2137
                self.match(CSharpParser.VOID)
                self.state = 2138
                self.identifier()
                self.state = 2140
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 2139
                    self.type_parameter_list()


                self.state = 2142
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 2144
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (CSharpParser.PARAMS - 74)) | (1 << (CSharpParser.PARTIAL - 74)) | (1 << (CSharpParser.REF - 74)) | (1 << (CSharpParser.REMOVE - 74)) | (1 << (CSharpParser.SBYTE - 74)) | (1 << (CSharpParser.SELECT - 74)) | (1 << (CSharpParser.SET - 74)) | (1 << (CSharpParser.SHORT - 74)) | (1 << (CSharpParser.STRING - 74)) | (1 << (CSharpParser.THIS - 74)) | (1 << (CSharpParser.UINT - 74)) | (1 << (CSharpParser.ULONG - 74)) | (1 << (CSharpParser.UNMANAGED - 74)) | (1 << (CSharpParser.USHORT - 74)) | (1 << (CSharpParser.VAR - 74)) | (1 << (CSharpParser.VOID - 74)) | (1 << (CSharpParser.WHEN - 74)) | (1 << (CSharpParser.WHERE - 74)) | (1 << (CSharpParser.YIELD - 74)) | (1 << (CSharpParser.IDENTIFIER - 74)) | (1 << (CSharpParser.OPEN_BRACKET - 74)) | (1 << (CSharpParser.OPEN_PARENS - 74)))) != 0):
                    self.state = 2143
                    self.formal_parameter_list()


                self.state = 2146
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 2148
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.WHERE:
                    self.state = 2147
                    self.type_parameter_constraints_clauses()


                self.state = 2150
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                self.state = 2152
                self.match(CSharpParser.EVENT)
                self.state = 2153
                self.type_()
                self.state = 2154
                self.identifier()
                self.state = 2155
                self.match(CSharpParser.SEMICOLON)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_accessorsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def SEMICOLON(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.SEMICOLON)
            else:
                return self.getToken(CSharpParser.SEMICOLON, i)

        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def attributes(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.AttributesContext)
            else:
                return self.getTypedRuleContext(CSharpParser.AttributesContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_accessors

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_accessors" ):
                listener.enterInterface_accessors(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_accessors" ):
                listener.exitInterface_accessors(self)




    def interface_accessors(self):

        localctx = CSharpParser.Interface_accessorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_interface_accessors)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2160
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 2159
                self.attributes()


            self.state = 2180
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.GET]:
                self.state = 2162
                self.match(CSharpParser.GET)
                self.state = 2163
                self.match(CSharpParser.SEMICOLON)
                self.state = 2169
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.SET or _la==CSharpParser.OPEN_BRACKET:
                    self.state = 2165
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.OPEN_BRACKET:
                        self.state = 2164
                        self.attributes()


                    self.state = 2167
                    self.match(CSharpParser.SET)
                    self.state = 2168
                    self.match(CSharpParser.SEMICOLON)


                pass
            elif token in [CSharpParser.SET]:
                self.state = 2171
                self.match(CSharpParser.SET)
                self.state = 2172
                self.match(CSharpParser.SEMICOLON)
                self.state = 2178
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.GET or _la==CSharpParser.OPEN_BRACKET:
                    self.state = 2174
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.OPEN_BRACKET:
                        self.state = 2173
                        self.attributes()


                    self.state = 2176
                    self.match(CSharpParser.GET)
                    self.state = 2177
                    self.match(CSharpParser.SEMICOLON)


                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 Enum_baseContext(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(CSharpParser.COLON, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_enum_base

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_base" ):
                listener.enterEnum_base(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_base" ):
                listener.exitEnum_base(self)




    def enum_base(self):

        localctx = CSharpParser.Enum_baseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_enum_base)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2182
            self.match(CSharpParser.COLON)
            self.state = 2183
            self.type_()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_bodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def enum_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Enum_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Enum_member_declarationContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_enum_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_body" ):
                listener.enterEnum_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_body" ):
                listener.exitEnum_body(self)




    def enum_body(self):

        localctx = CSharpParser.Enum_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_enum_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2185
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 2197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.OPEN_BRACKET - 64)))) != 0):
                self.state = 2186
                self.enum_member_declaration()
                self.state = 2191
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,268,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2187
                        self.match(CSharpParser.COMMA)
                        self.state = 2188
                        self.enum_member_declaration() 
                    self.state = 2193
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,268,self._ctx)

                self.state = 2195
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 2194
                    self.match(CSharpParser.COMMA)




            self.state = 2199
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_member_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_enum_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_member_declaration" ):
                listener.enterEnum_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_member_declaration" ):
                listener.exitEnum_member_declaration(self)




    def enum_member_declaration(self):

        localctx = CSharpParser.Enum_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_enum_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2202
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 2201
                self.attributes()


            self.state = 2204
            self.identifier()
            self.state = 2207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 2205
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 2206
                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_attribute_sectionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def global_attribute_target(self):
            return self.getTypedRuleContext(CSharpParser.Global_attribute_targetContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def attribute_list(self):
            return self.getTypedRuleContext(CSharpParser.Attribute_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_global_attribute_section

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_attribute_section" ):
                listener.enterGlobal_attribute_section(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_attribute_section" ):
                listener.exitGlobal_attribute_section(self)




    def global_attribute_section(self):

        localctx = CSharpParser.Global_attribute_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_global_attribute_section)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2209
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2210
            self.global_attribute_target()
            self.state = 2211
            self.match(CSharpParser.COLON)
            self.state = 2212
            self.attribute_list()
            self.state = 2214
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 2213
                self.match(CSharpParser.COMMA)


            self.state = 2216
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Global_attribute_targetContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def keyword(self):
            return self.getTypedRuleContext(CSharpParser.KeywordContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_global_attribute_target

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_attribute_target" ):
                listener.enterGlobal_attribute_target(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_attribute_target" ):
                listener.exitGlobal_attribute_target(self)




    def global_attribute_target(self):

        localctx = CSharpParser.Global_attribute_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_global_attribute_target)
        try:
            self.state = 2220
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,274,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2218
                self.keyword()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2219
                self.identifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Attribute_sectionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Attribute_sectionContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_attributes

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributes" ):
                listener.enterAttributes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributes" ):
                listener.exitAttributes(self)




    def attributes(self):

        localctx = CSharpParser.AttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2223 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 2222
                self.attribute_section()
                self.state = 2225 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.OPEN_BRACKET):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_sectionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def attribute_list(self):
            return self.getTypedRuleContext(CSharpParser.Attribute_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def attribute_target(self):
            return self.getTypedRuleContext(CSharpParser.Attribute_targetContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_section

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_section" ):
                listener.enterAttribute_section(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_section" ):
                listener.exitAttribute_section(self)




    def attribute_section(self):

        localctx = CSharpParser.Attribute_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_attribute_section)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2227
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2231
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,276,self._ctx)
            if la_ == 1:
                self.state = 2228
                self.attribute_target()
                self.state = 2229
                self.match(CSharpParser.COLON)


            self.state = 2233
            self.attribute_list()
            self.state = 2235
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 2234
                self.match(CSharpParser.COMMA)


            self.state = 2237
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_targetContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def keyword(self):
            return self.getTypedRuleContext(CSharpParser.KeywordContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_target

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_target" ):
                listener.enterAttribute_target(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_target" ):
                listener.exitAttribute_target(self)




    def attribute_target(self):

        localctx = CSharpParser.Attribute_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_attribute_target)
        try:
            self.state = 2241
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,278,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2239
                self.keyword()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2240
                self.identifier()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_listContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.AttributeContext)
            else:
                return self.getTypedRuleContext(CSharpParser.AttributeContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_list" ):
                listener.enterAttribute_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_list" ):
                listener.exitAttribute_list(self)




    def attribute_list(self):

        localctx = CSharpParser.Attribute_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_attribute_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2243
            self.attribute()
            self.state = 2248
            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 = 2244
                    self.match(CSharpParser.COMMA)
                    self.state = 2245
                    self.attribute() 
                self.state = 2250
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,279,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 AttributeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def attribute_argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Attribute_argumentContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Attribute_argumentContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute" ):
                listener.enterAttribute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute" ):
                listener.exitAttribute(self)




    def attribute(self):

        localctx = CSharpParser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2251
            self.namespace_or_type_name()
            self.state = 2264
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_PARENS:
                self.state = 2252
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 2261
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 2253
                    self.attribute_argument()
                    self.state = 2258
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==CSharpParser.COMMA:
                        self.state = 2254
                        self.match(CSharpParser.COMMA)
                        self.state = 2255
                        self.attribute_argument()
                        self.state = 2260
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2263
                self.match(CSharpParser.CLOSE_PARENS)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_argumentContext(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(CSharpParser.ExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_argument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_argument" ):
                listener.enterAttribute_argument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_argument" ):
                listener.exitAttribute_argument(self)




    def attribute_argument(self):

        localctx = CSharpParser.Attribute_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_attribute_argument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2269
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,283,self._ctx)
            if la_ == 1:
                self.state = 2266
                self.identifier()
                self.state = 2267
                self.match(CSharpParser.COLON)


            self.state = 2271
            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 Pointer_typeContext(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(CSharpParser.STAR, 0)

        def simple_type(self):
            return self.getTypedRuleContext(CSharpParser.Simple_typeContext,0)


        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)


        def INTERR(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.INTERR)
            else:
                return self.getToken(CSharpParser.INTERR, i)

        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_pointer_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointer_type" ):
                listener.enterPointer_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointer_type" ):
                listener.exitPointer_type(self)




    def pointer_type(self):

        localctx = CSharpParser.Pointer_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_pointer_type)
        self._la = 0 # Token type
        try:
            self.state = 2288
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2275
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.BOOL, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                    self.state = 2273
                    self.simple_type()
                    pass
                elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                    self.state = 2274
                    self.class_type()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2281
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.OPEN_BRACKET or _la==CSharpParser.INTERR:
                    self.state = 2279
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.OPEN_BRACKET]:
                        self.state = 2277
                        self.rank_specifier()
                        pass
                    elif token in [CSharpParser.INTERR]:
                        self.state = 2278
                        self.match(CSharpParser.INTERR)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 2283
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2284
                self.match(CSharpParser.STAR)
                pass
            elif token in [CSharpParser.VOID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2286
                self.match(CSharpParser.VOID)
                self.state = 2287
                self.match(CSharpParser.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 Fixed_pointer_declaratorsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fixed_pointer_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Fixed_pointer_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_pointer_declarators

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_pointer_declarators" ):
                listener.enterFixed_pointer_declarators(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_pointer_declarators" ):
                listener.exitFixed_pointer_declarators(self)




    def fixed_pointer_declarators(self):

        localctx = CSharpParser.Fixed_pointer_declaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_fixed_pointer_declarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2290
            self.fixed_pointer_declarator()
            self.state = 2295
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 2291
                self.match(CSharpParser.COMMA)
                self.state = 2292
                self.fixed_pointer_declarator()
                self.state = 2297
                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 Fixed_pointer_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def fixed_pointer_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_pointer_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_pointer_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_pointer_declarator" ):
                listener.enterFixed_pointer_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_pointer_declarator" ):
                listener.exitFixed_pointer_declarator(self)




    def fixed_pointer_declarator(self):

        localctx = CSharpParser.Fixed_pointer_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_fixed_pointer_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2298
            self.identifier()
            self.state = 2299
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 2300
            self.fixed_pointer_initializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_pointer_initializerContext(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(CSharpParser.ExpressionContext,0)


        def AMP(self):
            return self.getToken(CSharpParser.AMP, 0)

        def stackalloc_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Stackalloc_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_pointer_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_pointer_initializer" ):
                listener.enterFixed_pointer_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_pointer_initializer" ):
                listener.exitFixed_pointer_initializer(self)




    def fixed_pointer_initializer(self):

        localctx = CSharpParser.Fixed_pointer_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_fixed_pointer_initializer)
        try:
            self.state = 2307
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2303
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,289,self._ctx)
                if la_ == 1:
                    self.state = 2302
                    self.match(CSharpParser.AMP)


                self.state = 2305
                self.expression()
                pass
            elif token in [CSharpParser.STACKALLOC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2306
                self.stackalloc_initializer()
                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 Fixed_size_buffer_declaratorContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_size_buffer_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_size_buffer_declarator" ):
                listener.enterFixed_size_buffer_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_size_buffer_declarator" ):
                listener.exitFixed_size_buffer_declarator(self)




    def fixed_size_buffer_declarator(self):

        localctx = CSharpParser.Fixed_size_buffer_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_fixed_size_buffer_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2309
            self.identifier()
            self.state = 2310
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2311
            self.expression()
            self.state = 2312
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Stackalloc_initializerContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STACKALLOC(self):
            return self.getToken(CSharpParser.STACKALLOC, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_stackalloc_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStackalloc_initializer" ):
                listener.enterStackalloc_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStackalloc_initializer" ):
                listener.exitStackalloc_initializer(self)




    def stackalloc_initializer(self):

        localctx = CSharpParser.Stackalloc_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_stackalloc_initializer)
        self._la = 0 # Token type
        try:
            self.state = 2343
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,295,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 2314
                self.match(CSharpParser.STACKALLOC)
                self.state = 2315
                self.type_()
                self.state = 2316
                self.match(CSharpParser.OPEN_BRACKET)
                self.state = 2317
                self.expression()
                self.state = 2318
                self.match(CSharpParser.CLOSE_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 2320
                self.match(CSharpParser.STACKALLOC)
                self.state = 2322
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)))) != 0) or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CSharpParser.PARTIAL - 75)) | (1 << (CSharpParser.REMOVE - 75)) | (1 << (CSharpParser.SBYTE - 75)) | (1 << (CSharpParser.SELECT - 75)) | (1 << (CSharpParser.SET - 75)) | (1 << (CSharpParser.SHORT - 75)) | (1 << (CSharpParser.STRING - 75)) | (1 << (CSharpParser.UINT - 75)) | (1 << (CSharpParser.ULONG - 75)) | (1 << (CSharpParser.UNMANAGED - 75)) | (1 << (CSharpParser.USHORT - 75)) | (1 << (CSharpParser.VAR - 75)) | (1 << (CSharpParser.VOID - 75)) | (1 << (CSharpParser.WHEN - 75)) | (1 << (CSharpParser.WHERE - 75)) | (1 << (CSharpParser.YIELD - 75)) | (1 << (CSharpParser.IDENTIFIER - 75)) | (1 << (CSharpParser.OPEN_PARENS - 75)))) != 0):
                    self.state = 2321
                    self.type_()


                self.state = 2324
                self.match(CSharpParser.OPEN_BRACKET)
                self.state = 2326
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                    self.state = 2325
                    self.expression()


                self.state = 2328
                self.match(CSharpParser.CLOSE_BRACKET)
                self.state = 2329
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2330
                self.expression()
                self.state = 2335
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,293,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 2331
                        self.match(CSharpParser.COMMA)
                        self.state = 2332
                        self.expression() 
                    self.state = 2337
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,293,self._ctx)

                self.state = 2339
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 2338
                    self.match(CSharpParser.COMMA)


                self.state = 2341
                self.match(CSharpParser.CLOSE_BRACE)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_arrowContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.first = None # Token
            self.second = None # Token

        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_right_arrow

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRight_arrow" ):
                listener.enterRight_arrow(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRight_arrow" ):
                listener.exitRight_arrow(self)




    def right_arrow(self):

        localctx = CSharpParser.Right_arrowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_right_arrow)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2345
            localctx.first = self.match(CSharpParser.ASSIGNMENT)
            self.state = 2346
            localctx.second = self.match(CSharpParser.GT)
            self.state = 2347
            if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, "$first.index + 1 == $second.index")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_shiftContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.first = None # Token
            self.second = None # Token

        def GT(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.GT)
            else:
                return self.getToken(CSharpParser.GT, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_right_shift

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRight_shift" ):
                listener.enterRight_shift(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRight_shift" ):
                listener.exitRight_shift(self)




    def right_shift(self):

        localctx = CSharpParser.Right_shiftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_right_shift)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2349
            localctx.first = self.match(CSharpParser.GT)
            self.state = 2350
            localctx.second = self.match(CSharpParser.GT)
            self.state = 2351
            if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, "$first.index + 1 == $second.index")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_shift_assignmentContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.first = None # Token
            self.second = None # Token

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def OP_GE(self):
            return self.getToken(CSharpParser.OP_GE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_right_shift_assignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRight_shift_assignment" ):
                listener.enterRight_shift_assignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRight_shift_assignment" ):
                listener.exitRight_shift_assignment(self)




    def right_shift_assignment(self):

        localctx = CSharpParser.Right_shift_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_right_shift_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2353
            localctx.first = self.match(CSharpParser.GT)
            self.state = 2354
            localctx.second = self.match(CSharpParser.OP_GE)
            self.state = 2355
            if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, "$first.index + 1 == $second.index")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def boolean_literal(self):
            return self.getTypedRuleContext(CSharpParser.Boolean_literalContext,0)


        def string_literal(self):
            return self.getTypedRuleContext(CSharpParser.String_literalContext,0)


        def INTEGER_LITERAL(self):
            return self.getToken(CSharpParser.INTEGER_LITERAL, 0)

        def HEX_INTEGER_LITERAL(self):
            return self.getToken(CSharpParser.HEX_INTEGER_LITERAL, 0)

        def BIN_INTEGER_LITERAL(self):
            return self.getToken(CSharpParser.BIN_INTEGER_LITERAL, 0)

        def REAL_LITERAL(self):
            return self.getToken(CSharpParser.REAL_LITERAL, 0)

        def CHARACTER_LITERAL(self):
            return self.getToken(CSharpParser.CHARACTER_LITERAL, 0)

        def NULL_(self):
            return self.getToken(CSharpParser.NULL_, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteral" ):
                listener.enterLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteral" ):
                listener.exitLiteral(self)




    def literal(self):

        localctx = CSharpParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_literal)
        try:
            self.state = 2365
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.FALSE, CSharpParser.TRUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2357
                self.boolean_literal()
                pass
            elif token in [CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2358
                self.string_literal()
                pass
            elif token in [CSharpParser.INTEGER_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2359
                self.match(CSharpParser.INTEGER_LITERAL)
                pass
            elif token in [CSharpParser.HEX_INTEGER_LITERAL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2360
                self.match(CSharpParser.HEX_INTEGER_LITERAL)
                pass
            elif token in [CSharpParser.BIN_INTEGER_LITERAL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2361
                self.match(CSharpParser.BIN_INTEGER_LITERAL)
                pass
            elif token in [CSharpParser.REAL_LITERAL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2362
                self.match(CSharpParser.REAL_LITERAL)
                pass
            elif token in [CSharpParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2363
                self.match(CSharpParser.CHARACTER_LITERAL)
                pass
            elif token in [CSharpParser.NULL_]:
                self.enterOuterAlt(localctx, 8)
                self.state = 2364
                self.match(CSharpParser.NULL_)
                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 Boolean_literalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(CSharpParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(CSharpParser.FALSE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_boolean_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBoolean_literal" ):
                listener.enterBoolean_literal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBoolean_literal" ):
                listener.exitBoolean_literal(self)




    def boolean_literal(self):

        localctx = CSharpParser.Boolean_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_boolean_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2367
            _la = self._input.LA(1)
            if not(_la==CSharpParser.FALSE or _la==CSharpParser.TRUE):
                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 String_literalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interpolated_regular_string(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_regular_stringContext,0)


        def interpolated_verbatium_string(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_verbatium_stringContext,0)


        def REGULAR_STRING(self):
            return self.getToken(CSharpParser.REGULAR_STRING, 0)

        def VERBATIUM_STRING(self):
            return self.getToken(CSharpParser.VERBATIUM_STRING, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_string_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterString_literal" ):
                listener.enterString_literal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitString_literal" ):
                listener.exitString_literal(self)




    def string_literal(self):

        localctx = CSharpParser.String_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_string_literal)
        try:
            self.state = 2373
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.INTERPOLATED_REGULAR_STRING_START]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2369
                self.interpolated_regular_string()
                pass
            elif token in [CSharpParser.INTERPOLATED_VERBATIUM_STRING_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2370
                self.interpolated_verbatium_string()
                pass
            elif token in [CSharpParser.REGULAR_STRING]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2371
                self.match(CSharpParser.REGULAR_STRING)
                pass
            elif token in [CSharpParser.VERBATIUM_STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2372
                self.match(CSharpParser.VERBATIUM_STRING)
                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 Interpolated_regular_stringContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERPOLATED_REGULAR_STRING_START(self):
            return self.getToken(CSharpParser.INTERPOLATED_REGULAR_STRING_START, 0)

        def DOUBLE_QUOTE_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0)

        def interpolated_regular_string_part(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Interpolated_regular_string_partContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Interpolated_regular_string_partContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_regular_string

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_regular_string" ):
                listener.enterInterpolated_regular_string(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_regular_string" ):
                listener.exitInterpolated_regular_string(self)




    def interpolated_regular_string(self):

        localctx = CSharpParser.Interpolated_regular_stringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_interpolated_regular_string)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2375
            self.match(CSharpParser.INTERPOLATED_REGULAR_STRING_START)
            self.state = 2379
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)) | (1 << (CSharpParser.DOUBLE_CURLY_INSIDE - 129)) | (1 << (CSharpParser.REGULAR_CHAR_INSIDE - 129)) | (1 << (CSharpParser.REGULAR_STRING_INSIDE - 129)))) != 0):
                self.state = 2376
                self.interpolated_regular_string_part()
                self.state = 2381
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2382
            self.match(CSharpParser.DOUBLE_QUOTE_INSIDE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_verbatium_stringContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERPOLATED_VERBATIUM_STRING_START(self):
            return self.getToken(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, 0)

        def DOUBLE_QUOTE_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0)

        def interpolated_verbatium_string_part(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Interpolated_verbatium_string_partContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Interpolated_verbatium_string_partContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_verbatium_string

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_verbatium_string" ):
                listener.enterInterpolated_verbatium_string(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_verbatium_string" ):
                listener.exitInterpolated_verbatium_string(self)




    def interpolated_verbatium_string(self):

        localctx = CSharpParser.Interpolated_verbatium_stringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_interpolated_verbatium_string)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2384
            self.match(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START)
            self.state = 2388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)) | (1 << (CSharpParser.DOUBLE_CURLY_INSIDE - 129)) | (1 << (CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE - 129)) | (1 << (CSharpParser.VERBATIUM_INSIDE_STRING - 129)))) != 0):
                self.state = 2385
                self.interpolated_verbatium_string_part()
                self.state = 2390
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2391
            self.match(CSharpParser.DOUBLE_QUOTE_INSIDE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_regular_string_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interpolated_string_expression(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_string_expressionContext,0)


        def DOUBLE_CURLY_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0)

        def REGULAR_CHAR_INSIDE(self):
            return self.getToken(CSharpParser.REGULAR_CHAR_INSIDE, 0)

        def REGULAR_STRING_INSIDE(self):
            return self.getToken(CSharpParser.REGULAR_STRING_INSIDE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_regular_string_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_regular_string_part" ):
                listener.enterInterpolated_regular_string_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_regular_string_part" ):
                listener.exitInterpolated_regular_string_part(self)




    def interpolated_regular_string_part(self):

        localctx = CSharpParser.Interpolated_regular_string_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_interpolated_regular_string_part)
        try:
            self.state = 2397
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2393
                self.interpolated_string_expression()
                pass
            elif token in [CSharpParser.DOUBLE_CURLY_INSIDE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2394
                self.match(CSharpParser.DOUBLE_CURLY_INSIDE)
                pass
            elif token in [CSharpParser.REGULAR_CHAR_INSIDE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2395
                self.match(CSharpParser.REGULAR_CHAR_INSIDE)
                pass
            elif token in [CSharpParser.REGULAR_STRING_INSIDE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2396
                self.match(CSharpParser.REGULAR_STRING_INSIDE)
                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 Interpolated_verbatium_string_partContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interpolated_string_expression(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_string_expressionContext,0)


        def DOUBLE_CURLY_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0)

        def VERBATIUM_DOUBLE_QUOTE_INSIDE(self):
            return self.getToken(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE, 0)

        def VERBATIUM_INSIDE_STRING(self):
            return self.getToken(CSharpParser.VERBATIUM_INSIDE_STRING, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_verbatium_string_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_verbatium_string_part" ):
                listener.enterInterpolated_verbatium_string_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_verbatium_string_part" ):
                listener.exitInterpolated_verbatium_string_part(self)




    def interpolated_verbatium_string_part(self):

        localctx = CSharpParser.Interpolated_verbatium_string_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_interpolated_verbatium_string_part)
        try:
            self.state = 2403
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2399
                self.interpolated_string_expression()
                pass
            elif token in [CSharpParser.DOUBLE_CURLY_INSIDE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2400
                self.match(CSharpParser.DOUBLE_CURLY_INSIDE)
                pass
            elif token in [CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2401
                self.match(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE)
                pass
            elif token in [CSharpParser.VERBATIUM_INSIDE_STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2402
                self.match(CSharpParser.VERBATIUM_INSIDE_STRING)
                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 Interpolated_string_expressionContext(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(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def FORMAT_STRING(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.FORMAT_STRING)
            else:
                return self.getToken(CSharpParser.FORMAT_STRING, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_string_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_string_expression" ):
                listener.enterInterpolated_string_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_string_expression" ):
                listener.exitInterpolated_string_expression(self)




    def interpolated_string_expression(self):

        localctx = CSharpParser.Interpolated_string_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 394, self.RULE_interpolated_string_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2405
            self.expression()
            self.state = 2410
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 2406
                self.match(CSharpParser.COMMA)
                self.state = 2407
                self.expression()
                self.state = 2412
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2419
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2413
                self.match(CSharpParser.COLON)
                self.state = 2415 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2414
                    self.match(CSharpParser.FORMAT_STRING)
                    self.state = 2417 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==CSharpParser.FORMAT_STRING):
                        break



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class KeywordContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ABSTRACT(self):
            return self.getToken(CSharpParser.ABSTRACT, 0)

        def AS(self):
            return self.getToken(CSharpParser.AS, 0)

        def BASE(self):
            return self.getToken(CSharpParser.BASE, 0)

        def BOOL(self):
            return self.getToken(CSharpParser.BOOL, 0)

        def BREAK(self):
            return self.getToken(CSharpParser.BREAK, 0)

        def BYTE(self):
            return self.getToken(CSharpParser.BYTE, 0)

        def CASE(self):
            return self.getToken(CSharpParser.CASE, 0)

        def CATCH(self):
            return self.getToken(CSharpParser.CATCH, 0)

        def CHAR(self):
            return self.getToken(CSharpParser.CHAR, 0)

        def CHECKED(self):
            return self.getToken(CSharpParser.CHECKED, 0)

        def CLASS(self):
            return self.getToken(CSharpParser.CLASS, 0)

        def CONST(self):
            return self.getToken(CSharpParser.CONST, 0)

        def CONTINUE(self):
            return self.getToken(CSharpParser.CONTINUE, 0)

        def DECIMAL(self):
            return self.getToken(CSharpParser.DECIMAL, 0)

        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)

        def DELEGATE(self):
            return self.getToken(CSharpParser.DELEGATE, 0)

        def DO(self):
            return self.getToken(CSharpParser.DO, 0)

        def DOUBLE(self):
            return self.getToken(CSharpParser.DOUBLE, 0)

        def ELSE(self):
            return self.getToken(CSharpParser.ELSE, 0)

        def ENUM(self):
            return self.getToken(CSharpParser.ENUM, 0)

        def EVENT(self):
            return self.getToken(CSharpParser.EVENT, 0)

        def EXPLICIT(self):
            return self.getToken(CSharpParser.EXPLICIT, 0)

        def EXTERN(self):
            return self.getToken(CSharpParser.EXTERN, 0)

        def FALSE(self):
            return self.getToken(CSharpParser.FALSE, 0)

        def FINALLY(self):
            return self.getToken(CSharpParser.FINALLY, 0)

        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)

        def FLOAT(self):
            return self.getToken(CSharpParser.FLOAT, 0)

        def FOR(self):
            return self.getToken(CSharpParser.FOR, 0)

        def FOREACH(self):
            return self.getToken(CSharpParser.FOREACH, 0)

        def GOTO(self):
            return self.getToken(CSharpParser.GOTO, 0)

        def IF(self):
            return self.getToken(CSharpParser.IF, 0)

        def IMPLICIT(self):
            return self.getToken(CSharpParser.IMPLICIT, 0)

        def IN(self):
            return self.getToken(CSharpParser.IN, 0)

        def INT(self):
            return self.getToken(CSharpParser.INT, 0)

        def INTERFACE(self):
            return self.getToken(CSharpParser.INTERFACE, 0)

        def INTERNAL(self):
            return self.getToken(CSharpParser.INTERNAL, 0)

        def IS(self):
            return self.getToken(CSharpParser.IS, 0)

        def LOCK(self):
            return self.getToken(CSharpParser.LOCK, 0)

        def LONG(self):
            return self.getToken(CSharpParser.LONG, 0)

        def NAMESPACE(self):
            return self.getToken(CSharpParser.NAMESPACE, 0)

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def NULL_(self):
            return self.getToken(CSharpParser.NULL_, 0)

        def OBJECT(self):
            return self.getToken(CSharpParser.OBJECT, 0)

        def OPERATOR(self):
            return self.getToken(CSharpParser.OPERATOR, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

        def OVERRIDE(self):
            return self.getToken(CSharpParser.OVERRIDE, 0)

        def PARAMS(self):
            return self.getToken(CSharpParser.PARAMS, 0)

        def PRIVATE(self):
            return self.getToken(CSharpParser.PRIVATE, 0)

        def PROTECTED(self):
            return self.getToken(CSharpParser.PROTECTED, 0)

        def PUBLIC(self):
            return self.getToken(CSharpParser.PUBLIC, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def RETURN(self):
            return self.getToken(CSharpParser.RETURN, 0)

        def SBYTE(self):
            return self.getToken(CSharpParser.SBYTE, 0)

        def SEALED(self):
            return self.getToken(CSharpParser.SEALED, 0)

        def SHORT(self):
            return self.getToken(CSharpParser.SHORT, 0)

        def SIZEOF(self):
            return self.getToken(CSharpParser.SIZEOF, 0)

        def STACKALLOC(self):
            return self.getToken(CSharpParser.STACKALLOC, 0)

        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)

        def STRING(self):
            return self.getToken(CSharpParser.STRING, 0)

        def STRUCT(self):
            return self.getToken(CSharpParser.STRUCT, 0)

        def SWITCH(self):
            return self.getToken(CSharpParser.SWITCH, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def THROW(self):
            return self.getToken(CSharpParser.THROW, 0)

        def TRUE(self):
            return self.getToken(CSharpParser.TRUE, 0)

        def TRY(self):
            return self.getToken(CSharpParser.TRY, 0)

        def TYPEOF(self):
            return self.getToken(CSharpParser.TYPEOF, 0)

        def UINT(self):
            return self.getToken(CSharpParser.UINT, 0)

        def ULONG(self):
            return self.getToken(CSharpParser.ULONG, 0)

        def UNCHECKED(self):
            return self.getToken(CSharpParser.UNCHECKED, 0)

        def UNMANAGED(self):
            return self.getToken(CSharpParser.UNMANAGED, 0)

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def USHORT(self):
            return self.getToken(CSharpParser.USHORT, 0)

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)

        def VIRTUAL(self):
            return self.getToken(CSharpParser.VIRTUAL, 0)

        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def VOLATILE(self):
            return self.getToken(CSharpParser.VOLATILE, 0)

        def WHILE(self):
            return self.getToken(CSharpParser.WHILE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_keyword

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterKeyword" ):
                listener.enterKeyword(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitKeyword" ):
                listener.exitKeyword(self)




    def keyword(self):

        localctx = CSharpParser.KeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_keyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2421
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.AS) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BREAK) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CASE) | (1 << CSharpParser.CATCH) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.CONTINUE) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DO) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.ELSE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FINALLY) | (1 << CSharpParser.FIXED) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FOR) | (1 << CSharpParser.FOREACH) | (1 << CSharpParser.GOTO) | (1 << CSharpParser.IF) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.IN) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.IS) | (1 << CSharpParser.LOCK) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NAMESPACE - 65)) | (1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL_ - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.OPERATOR - 65)) | (1 << (CSharpParser.OUT - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARAMS - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.RETURN - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STACKALLOC - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.SWITCH - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.THROW - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TRY - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.UNMANAGED - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.USING - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.WHILE - 65)))) != 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 Class_definitionContext(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(CSharpParser.CLASS, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def class_body(self):
            return self.getTypedRuleContext(CSharpParser.Class_bodyContext,0)


        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def class_base(self):
            return self.getTypedRuleContext(CSharpParser.Class_baseContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_class_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_definition" ):
                listener.enterClass_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_definition" ):
                listener.exitClass_definition(self)




    def class_definition(self):

        localctx = CSharpParser.Class_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_class_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2423
            self.match(CSharpParser.CLASS)
            self.state = 2424
            self.identifier()
            self.state = 2426
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2425
                self.type_parameter_list()


            self.state = 2429
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2428
                self.class_base()


            self.state = 2432
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2431
                self.type_parameter_constraints_clauses()


            self.state = 2434
            self.class_body()
            self.state = 2436
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2435
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRUCT(self):
            return self.getToken(CSharpParser.STRUCT, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def struct_body(self):
            return self.getTypedRuleContext(CSharpParser.Struct_bodyContext,0)


        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def struct_interfaces(self):
            return self.getTypedRuleContext(CSharpParser.Struct_interfacesContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_struct_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStruct_definition" ):
                listener.enterStruct_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStruct_definition" ):
                listener.exitStruct_definition(self)




    def struct_definition(self):

        localctx = CSharpParser.Struct_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 400, self.RULE_struct_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.READONLY or _la==CSharpParser.REF:
                self.state = 2438
                _la = self._input.LA(1)
                if not(_la==CSharpParser.READONLY or _la==CSharpParser.REF):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 2441
            self.match(CSharpParser.STRUCT)
            self.state = 2442
            self.identifier()
            self.state = 2444
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2443
                self.type_parameter_list()


            self.state = 2447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2446
                self.struct_interfaces()


            self.state = 2450
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2449
                self.type_parameter_constraints_clauses()


            self.state = 2452
            self.struct_body()
            self.state = 2454
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2453
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERFACE(self):
            return self.getToken(CSharpParser.INTERFACE, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def class_body(self):
            return self.getTypedRuleContext(CSharpParser.Class_bodyContext,0)


        def variant_type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Variant_type_parameter_listContext,0)


        def interface_base(self):
            return self.getTypedRuleContext(CSharpParser.Interface_baseContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_interface_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_definition" ):
                listener.enterInterface_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_definition" ):
                listener.exitInterface_definition(self)




    def interface_definition(self):

        localctx = CSharpParser.Interface_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_interface_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2456
            self.match(CSharpParser.INTERFACE)
            self.state = 2457
            self.identifier()
            self.state = 2459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2458
                self.variant_type_parameter_list()


            self.state = 2462
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2461
                self.interface_base()


            self.state = 2465
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2464
                self.type_parameter_constraints_clauses()


            self.state = 2467
            self.class_body()
            self.state = 2469
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2468
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENUM(self):
            return self.getToken(CSharpParser.ENUM, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def enum_body(self):
            return self.getTypedRuleContext(CSharpParser.Enum_bodyContext,0)


        def enum_base(self):
            return self.getTypedRuleContext(CSharpParser.Enum_baseContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_enum_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_definition" ):
                listener.enterEnum_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_definition" ):
                listener.exitEnum_definition(self)




    def enum_definition(self):

        localctx = CSharpParser.Enum_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 404, self.RULE_enum_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2471
            self.match(CSharpParser.ENUM)
            self.state = 2472
            self.identifier()
            self.state = 2474
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2473
                self.enum_base()


            self.state = 2476
            self.enum_body()
            self.state = 2478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2477
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Delegate_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DELEGATE(self):
            return self.getToken(CSharpParser.DELEGATE, 0)

        def return_type(self):
            return self.getTypedRuleContext(CSharpParser.Return_typeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def variant_type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Variant_type_parameter_listContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_delegate_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDelegate_definition" ):
                listener.enterDelegate_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDelegate_definition" ):
                listener.exitDelegate_definition(self)




    def delegate_definition(self):

        localctx = CSharpParser.Delegate_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 406, self.RULE_delegate_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2480
            self.match(CSharpParser.DELEGATE)
            self.state = 2481
            self.return_type()
            self.state = 2482
            self.identifier()
            self.state = 2484
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2483
                self.variant_type_parameter_list()


            self.state = 2486
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2488
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (CSharpParser.PARAMS - 74)) | (1 << (CSharpParser.PARTIAL - 74)) | (1 << (CSharpParser.REF - 74)) | (1 << (CSharpParser.REMOVE - 74)) | (1 << (CSharpParser.SBYTE - 74)) | (1 << (CSharpParser.SELECT - 74)) | (1 << (CSharpParser.SET - 74)) | (1 << (CSharpParser.SHORT - 74)) | (1 << (CSharpParser.STRING - 74)) | (1 << (CSharpParser.THIS - 74)) | (1 << (CSharpParser.UINT - 74)) | (1 << (CSharpParser.ULONG - 74)) | (1 << (CSharpParser.UNMANAGED - 74)) | (1 << (CSharpParser.USHORT - 74)) | (1 << (CSharpParser.VAR - 74)) | (1 << (CSharpParser.VOID - 74)) | (1 << (CSharpParser.WHEN - 74)) | (1 << (CSharpParser.WHERE - 74)) | (1 << (CSharpParser.YIELD - 74)) | (1 << (CSharpParser.IDENTIFIER - 74)) | (1 << (CSharpParser.OPEN_BRACKET - 74)) | (1 << (CSharpParser.OPEN_PARENS - 74)))) != 0):
                self.state = 2487
                self.formal_parameter_list()


            self.state = 2490
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2492
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2491
                self.type_parameter_constraints_clauses()


            self.state = 2494
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Event_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EVENT(self):
            return self.getToken(CSharpParser.EVENT, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def variable_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Variable_declaratorsContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def member_name(self):
            return self.getTypedRuleContext(CSharpParser.Member_nameContext,0)


        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def event_accessor_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Event_accessor_declarationsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_event_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEvent_declaration" ):
                listener.enterEvent_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEvent_declaration" ):
                listener.exitEvent_declaration(self)




    def event_declaration(self):

        localctx = CSharpParser.Event_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 408, self.RULE_event_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2496
            self.match(CSharpParser.EVENT)
            self.state = 2497
            self.type_()
            self.state = 2506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,323,self._ctx)
            if la_ == 1:
                self.state = 2498
                self.variable_declarators()
                self.state = 2499
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                self.state = 2501
                self.member_name()
                self.state = 2502
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2503
                self.event_accessor_declarations()
                self.state = 2504
                self.match(CSharpParser.CLOSE_BRACE)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Field_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variable_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Variable_declaratorsContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_field_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterField_declaration" ):
                listener.enterField_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitField_declaration" ):
                listener.exitField_declaration(self)




    def field_declaration(self):

        localctx = CSharpParser.Field_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 410, self.RULE_field_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2508
            self.variable_declarators()
            self.state = 2509
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Property_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def member_name(self):
            return self.getTypedRuleContext(CSharpParser.Member_nameContext,0)


        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def accessor_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_declarationsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def variable_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_property_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProperty_declaration" ):
                listener.enterProperty_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProperty_declaration" ):
                listener.exitProperty_declaration(self)




    def property_declaration(self):

        localctx = CSharpParser.Property_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 412, self.RULE_property_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2511
            self.member_name()
            self.state = 2525
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.state = 2512
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2513
                self.accessor_declarations()
                self.state = 2514
                self.match(CSharpParser.CLOSE_BRACE)
                self.state = 2519
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.ASSIGNMENT:
                    self.state = 2515
                    self.match(CSharpParser.ASSIGNMENT)
                    self.state = 2516
                    self.variable_initializer()
                    self.state = 2517
                    self.match(CSharpParser.SEMICOLON)


                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2521
                self.right_arrow()
                self.state = 2522
                self.throwable_expression()
                self.state = 2523
                self.match(CSharpParser.SEMICOLON)
                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 Constant_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CONST(self):
            return self.getToken(CSharpParser.CONST, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def constant_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Constant_declaratorsContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_constant_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstant_declaration" ):
                listener.enterConstant_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstant_declaration" ):
                listener.exitConstant_declaration(self)




    def constant_declaration(self):

        localctx = CSharpParser.Constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 414, self.RULE_constant_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2527
            self.match(CSharpParser.CONST)
            self.state = 2528
            self.type_()
            self.state = 2529
            self.constant_declarators()
            self.state = 2530
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Indexer_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def accessor_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_declarationsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_indexer_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIndexer_declaration" ):
                listener.enterIndexer_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIndexer_declaration" ):
                listener.exitIndexer_declaration(self)




    def indexer_declaration(self):

        localctx = CSharpParser.Indexer_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 416, self.RULE_indexer_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2532
            self.match(CSharpParser.THIS)
            self.state = 2533
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2534
            self.formal_parameter_list()
            self.state = 2535
            self.match(CSharpParser.CLOSE_BRACKET)
            self.state = 2544
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.state = 2536
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2537
                self.accessor_declarations()
                self.state = 2538
                self.match(CSharpParser.CLOSE_BRACE)
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2540
                self.right_arrow()
                self.state = 2541
                self.throwable_expression()
                self.state = 2542
                self.match(CSharpParser.SEMICOLON)
                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 Destructor_definitionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TILDE(self):
            return self.getToken(CSharpParser.TILDE, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_destructor_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDestructor_definition" ):
                listener.enterDestructor_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDestructor_definition" ):
                listener.exitDestructor_definition(self)




    def destructor_definition(self):

        localctx = CSharpParser.Destructor_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 418, self.RULE_destructor_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2546
            self.match(CSharpParser.TILDE)
            self.state = 2547
            self.identifier()
            self.state = 2548
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2549
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2550
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constructor_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def constructor_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Constructor_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_constructor_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructor_declaration" ):
                listener.enterConstructor_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructor_declaration" ):
                listener.exitConstructor_declaration(self)




    def constructor_declaration(self):

        localctx = CSharpParser.Constructor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 420, self.RULE_constructor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2552
            self.identifier()
            self.state = 2553
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (CSharpParser.PARAMS - 74)) | (1 << (CSharpParser.PARTIAL - 74)) | (1 << (CSharpParser.REF - 74)) | (1 << (CSharpParser.REMOVE - 74)) | (1 << (CSharpParser.SBYTE - 74)) | (1 << (CSharpParser.SELECT - 74)) | (1 << (CSharpParser.SET - 74)) | (1 << (CSharpParser.SHORT - 74)) | (1 << (CSharpParser.STRING - 74)) | (1 << (CSharpParser.THIS - 74)) | (1 << (CSharpParser.UINT - 74)) | (1 << (CSharpParser.ULONG - 74)) | (1 << (CSharpParser.UNMANAGED - 74)) | (1 << (CSharpParser.USHORT - 74)) | (1 << (CSharpParser.VAR - 74)) | (1 << (CSharpParser.VOID - 74)) | (1 << (CSharpParser.WHEN - 74)) | (1 << (CSharpParser.WHERE - 74)) | (1 << (CSharpParser.YIELD - 74)) | (1 << (CSharpParser.IDENTIFIER - 74)) | (1 << (CSharpParser.OPEN_BRACKET - 74)) | (1 << (CSharpParser.OPEN_PARENS - 74)))) != 0):
                self.state = 2554
                self.formal_parameter_list()


            self.state = 2557
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2559
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2558
                self.constructor_initializer()


            self.state = 2561
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Method_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def method_member_name(self):
            return self.getTypedRuleContext(CSharpParser.Method_member_nameContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def method_body(self):
            return self.getTypedRuleContext(CSharpParser.Method_bodyContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_method_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_declaration" ):
                listener.enterMethod_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_declaration" ):
                listener.exitMethod_declaration(self)




    def method_declaration(self):

        localctx = CSharpParser.Method_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 422, self.RULE_method_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2563
            self.method_member_name()
            self.state = 2565
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2564
                self.type_parameter_list()


            self.state = 2567
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2569
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 10)) & ~0x3f) == 0 and ((1 << (_la - 10)) & ((1 << (CSharpParser.ADD - 10)) | (1 << (CSharpParser.ALIAS - 10)) | (1 << (CSharpParser.ARGLIST - 10)) | (1 << (CSharpParser.ASCENDING - 10)) | (1 << (CSharpParser.ASYNC - 10)) | (1 << (CSharpParser.AWAIT - 10)) | (1 << (CSharpParser.BOOL - 10)) | (1 << (CSharpParser.BY - 10)) | (1 << (CSharpParser.BYTE - 10)) | (1 << (CSharpParser.CHAR - 10)) | (1 << (CSharpParser.DECIMAL - 10)) | (1 << (CSharpParser.DESCENDING - 10)) | (1 << (CSharpParser.DOUBLE - 10)) | (1 << (CSharpParser.DYNAMIC - 10)) | (1 << (CSharpParser.EQUALS - 10)) | (1 << (CSharpParser.FLOAT - 10)) | (1 << (CSharpParser.FROM - 10)) | (1 << (CSharpParser.GET - 10)) | (1 << (CSharpParser.GROUP - 10)) | (1 << (CSharpParser.IN - 10)) | (1 << (CSharpParser.INT - 10)) | (1 << (CSharpParser.INTO - 10)) | (1 << (CSharpParser.JOIN - 10)) | (1 << (CSharpParser.LET - 10)) | (1 << (CSharpParser.LONG - 10)) | (1 << (CSharpParser.NAMEOF - 10)) | (1 << (CSharpParser.OBJECT - 10)) | (1 << (CSharpParser.ON - 10)) | (1 << (CSharpParser.ORDERBY - 10)) | (1 << (CSharpParser.OUT - 10)))) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & ((1 << (CSharpParser.PARAMS - 74)) | (1 << (CSharpParser.PARTIAL - 74)) | (1 << (CSharpParser.REF - 74)) | (1 << (CSharpParser.REMOVE - 74)) | (1 << (CSharpParser.SBYTE - 74)) | (1 << (CSharpParser.SELECT - 74)) | (1 << (CSharpParser.SET - 74)) | (1 << (CSharpParser.SHORT - 74)) | (1 << (CSharpParser.STRING - 74)) | (1 << (CSharpParser.THIS - 74)) | (1 << (CSharpParser.UINT - 74)) | (1 << (CSharpParser.ULONG - 74)) | (1 << (CSharpParser.UNMANAGED - 74)) | (1 << (CSharpParser.USHORT - 74)) | (1 << (CSharpParser.VAR - 74)) | (1 << (CSharpParser.VOID - 74)) | (1 << (CSharpParser.WHEN - 74)) | (1 << (CSharpParser.WHERE - 74)) | (1 << (CSharpParser.YIELD - 74)) | (1 << (CSharpParser.IDENTIFIER - 74)) | (1 << (CSharpParser.OPEN_BRACKET - 74)) | (1 << (CSharpParser.OPEN_PARENS - 74)))) != 0):
                self.state = 2568
                self.formal_parameter_list()


            self.state = 2571
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2573
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2572
                self.type_parameter_constraints_clauses()


            self.state = 2580
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:
                self.state = 2575
                self.method_body()
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2576
                self.right_arrow()
                self.state = 2577
                self.throwable_expression()
                self.state = 2578
                self.match(CSharpParser.SEMICOLON)
                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 Method_member_nameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def DOUBLE_COLON(self):
            return self.getToken(CSharpParser.DOUBLE_COLON, 0)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.DOT)
            else:
                return self.getToken(CSharpParser.DOT, i)

        def type_argument_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_argument_listContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_method_member_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_member_name" ):
                listener.enterMethod_member_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_member_name" ):
                listener.exitMethod_member_name(self)




    def method_member_name(self):

        localctx = CSharpParser.Method_member_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 424, self.RULE_method_member_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2587
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,333,self._ctx)
            if la_ == 1:
                self.state = 2582
                self.identifier()
                pass

            elif la_ == 2:
                self.state = 2583
                self.identifier()
                self.state = 2584
                self.match(CSharpParser.DOUBLE_COLON)
                self.state = 2585
                self.identifier()
                pass


            self.state = 2596
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,335,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2590
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.LT:
                        self.state = 2589
                        self.type_argument_list()


                    self.state = 2592
                    self.match(CSharpParser.DOT)
                    self.state = 2593
                    self.identifier() 
                self.state = 2598
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,335,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 Operator_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPERATOR(self):
            return self.getToken(CSharpParser.OPERATOR, 0)

        def overloadable_operator(self):
            return self.getTypedRuleContext(CSharpParser.Overloadable_operatorContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def arg_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Arg_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,i)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def throwable_expression(self):
            return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def IN(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.IN)
            else:
                return self.getToken(CSharpParser.IN, i)

        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_operator_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOperator_declaration" ):
                listener.enterOperator_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOperator_declaration" ):
                listener.exitOperator_declaration(self)




    def operator_declaration(self):

        localctx = CSharpParser.Operator_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 426, self.RULE_operator_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2599
            self.match(CSharpParser.OPERATOR)
            self.state = 2600
            self.overloadable_operator()
            self.state = 2601
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2603
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.IN:
                self.state = 2602
                self.match(CSharpParser.IN)


            self.state = 2605
            self.arg_declaration()
            self.state = 2611
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 2606
                self.match(CSharpParser.COMMA)
                self.state = 2608
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.IN:
                    self.state = 2607
                    self.match(CSharpParser.IN)


                self.state = 2610
                self.arg_declaration()


            self.state = 2613
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2619
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:
                self.state = 2614
                self.body()
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2615
                self.right_arrow()
                self.state = 2616
                self.throwable_expression()
                self.state = 2617
                self.match(CSharpParser.SEMICOLON)
                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 Arg_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_(self):
            return self.getTypedRuleContext(CSharpParser.Type_Context,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_arg_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArg_declaration" ):
                listener.enterArg_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArg_declaration" ):
                listener.exitArg_declaration(self)




    def arg_declaration(self):

        localctx = CSharpParser.Arg_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 428, self.RULE_arg_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2621
            self.type_()
            self.state = 2622
            self.identifier()
            self.state = 2625
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 2623
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 2624
                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 Method_invocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_method_invocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_invocation" ):
                listener.enterMethod_invocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_invocation" ):
                listener.exitMethod_invocation(self)




    def method_invocation(self):

        localctx = CSharpParser.Method_invocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 430, self.RULE_method_invocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2627
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2629
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IN) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.OUT - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                self.state = 2628
                self.argument_list()


            self.state = 2631
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Object_creation_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)


        def object_or_collection_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_object_creation_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterObject_creation_expression" ):
                listener.enterObject_creation_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitObject_creation_expression" ):
                listener.exitObject_creation_expression(self)




    def object_creation_expression(self):

        localctx = CSharpParser.Object_creation_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 432, self.RULE_object_creation_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2633
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2635
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IN) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL_ - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.OUT - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)) | (1 << (CSharpParser.LITERAL_ACCESS - 64)) | (1 << (CSharpParser.INTEGER_LITERAL - 64)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.BIN_INTEGER_LITERAL - 64)) | (1 << (CSharpParser.REAL_LITERAL - 64)) | (1 << (CSharpParser.CHARACTER_LITERAL - 64)) | (1 << (CSharpParser.REGULAR_STRING - 64)) | (1 << (CSharpParser.VERBATIUM_STRING - 64)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 64)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 64)))) != 0) or ((((_la - 129)) & ~0x3f) == 0 and ((1 << (_la - 129)) & ((1 << (CSharpParser.OPEN_PARENS - 129)) | (1 << (CSharpParser.PLUS - 129)) | (1 << (CSharpParser.MINUS - 129)) | (1 << (CSharpParser.STAR - 129)) | (1 << (CSharpParser.AMP - 129)) | (1 << (CSharpParser.CARET - 129)) | (1 << (CSharpParser.BANG - 129)) | (1 << (CSharpParser.TILDE - 129)) | (1 << (CSharpParser.OP_INC - 129)) | (1 << (CSharpParser.OP_DEC - 129)) | (1 << (CSharpParser.OP_RANGE - 129)))) != 0):
                self.state = 2634
                self.argument_list()


            self.state = 2637
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2639
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,343,self._ctx)
            if la_ == 1:
                self.state = 2638
                self.object_or_collection_initializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IdentifierContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(CSharpParser.IDENTIFIER, 0)

        def ADD(self):
            return self.getToken(CSharpParser.ADD, 0)

        def ALIAS(self):
            return self.getToken(CSharpParser.ALIAS, 0)

        def ARGLIST(self):
            return self.getToken(CSharpParser.ARGLIST, 0)

        def ASCENDING(self):
            return self.getToken(CSharpParser.ASCENDING, 0)

        def ASYNC(self):
            return self.getToken(CSharpParser.ASYNC, 0)

        def AWAIT(self):
            return self.getToken(CSharpParser.AWAIT, 0)

        def BY(self):
            return self.getToken(CSharpParser.BY, 0)

        def DESCENDING(self):
            return self.getToken(CSharpParser.DESCENDING, 0)

        def DYNAMIC(self):
            return self.getToken(CSharpParser.DYNAMIC, 0)

        def EQUALS(self):
            return self.getToken(CSharpParser.EQUALS, 0)

        def FROM(self):
            return self.getToken(CSharpParser.FROM, 0)

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def GROUP(self):
            return self.getToken(CSharpParser.GROUP, 0)

        def INTO(self):
            return self.getToken(CSharpParser.INTO, 0)

        def JOIN(self):
            return self.getToken(CSharpParser.JOIN, 0)

        def LET(self):
            return self.getToken(CSharpParser.LET, 0)

        def NAMEOF(self):
            return self.getToken(CSharpParser.NAMEOF, 0)

        def ON(self):
            return self.getToken(CSharpParser.ON, 0)

        def ORDERBY(self):
            return self.getToken(CSharpParser.ORDERBY, 0)

        def PARTIAL(self):
            return self.getToken(CSharpParser.PARTIAL, 0)

        def REMOVE(self):
            return self.getToken(CSharpParser.REMOVE, 0)

        def SELECT(self):
            return self.getToken(CSharpParser.SELECT, 0)

        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def UNMANAGED(self):
            return self.getToken(CSharpParser.UNMANAGED, 0)

        def VAR(self):
            return self.getToken(CSharpParser.VAR, 0)

        def WHEN(self):
            return self.getToken(CSharpParser.WHEN, 0)

        def WHERE(self):
            return self.getToken(CSharpParser.WHERE, 0)

        def YIELD(self):
            return self.getToken(CSharpParser.YIELD, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_identifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdentifier" ):
                listener.enterIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdentifier" ):
                listener.exitIdentifier(self)




    def identifier(self):

        localctx = CSharpParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 434, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2641
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMEOF - 64)) | (1 << (CSharpParser.ON - 64)) | (1 << (CSharpParser.ORDERBY - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.REMOVE - 64)) | (1 << (CSharpParser.SELECT - 64)) | (1 << (CSharpParser.SET - 64)) | (1 << (CSharpParser.UNMANAGED - 64)) | (1 << (CSharpParser.VAR - 64)) | (1 << (CSharpParser.WHEN - 64)) | (1 << (CSharpParser.WHERE - 64)) | (1 << (CSharpParser.YIELD - 64)) | (1 << (CSharpParser.IDENTIFIER - 64)))) != 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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[86] = self.local_variable_declaration_sempred
        self._predicates[187] = self.right_arrow_sempred
        self._predicates[188] = self.right_shift_sempred
        self._predicates[189] = self.right_shift_assignment_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 local_variable_declaration_sempred(self, localctx:Local_variable_declarationContext, predIndex:int):
            if predIndex == 0:
                return  this.IsLocalVariableDeclaration() 
         

    def right_arrow_sempred(self, localctx:Right_arrowContext, predIndex:int):
            if predIndex == 1:
                return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)
         

    def right_shift_sempred(self, localctx:Right_shiftContext, predIndex:int):
            if predIndex == 2:
                return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)
         

    def right_shift_assignment_sempred(self, localctx:Right_shift_assignmentContext, predIndex:int):
            if predIndex == 3:
                return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)
         




