CSharpLexerParser.py

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

def serializedATN():
    return [
        4,1,130,562,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,1,
        0,1,0,1,0,1,0,3,0,123,8,0,1,0,1,0,1,1,1,1,1,1,1,1,5,1,131,8,1,10,
        1,12,1,134,9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,4,1,
        4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,158,8,4,1,5,1,5,1,5,1,
        5,1,5,1,5,3,5,166,8,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,176,8,
        6,1,7,1,7,1,7,5,7,181,8,7,10,7,12,7,184,9,7,1,8,1,8,1,8,5,8,189,
        8,8,10,8,12,8,192,9,8,1,9,1,9,1,9,5,9,197,8,9,10,9,12,9,200,9,9,
        1,10,1,10,1,10,5,10,205,8,10,10,10,12,10,208,9,10,1,11,1,11,1,11,
        5,11,213,8,11,10,11,12,11,216,9,11,1,12,1,12,1,12,5,12,221,8,12,
        10,12,12,12,224,9,12,1,13,1,13,1,13,5,13,229,8,13,10,13,12,13,232,
        9,13,1,14,1,14,1,14,1,14,1,14,1,14,3,14,240,8,14,1,15,1,15,1,15,
        1,15,1,16,1,16,1,17,1,17,1,17,1,17,1,17,3,17,253,8,17,1,18,1,18,
        1,18,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,5,20,267,8,20,
        10,20,12,20,270,9,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,3,21,
        280,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,289,8,22,1,23,1,
        23,1,23,1,23,1,23,1,23,4,23,297,8,23,11,23,12,23,298,1,23,1,23,1,
        24,4,24,304,8,24,11,24,12,24,305,1,24,5,24,309,8,24,10,24,12,24,
        312,9,24,4,24,314,8,24,11,24,12,24,315,1,25,1,25,1,25,1,25,1,25,
        1,25,3,25,324,8,25,1,26,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,
        1,27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,3,28,343,8,28,1,28,1,28,
        3,28,347,8,28,1,28,1,28,3,28,351,8,28,1,28,1,28,1,28,1,29,1,29,3,
        29,358,8,29,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,
        32,1,32,5,32,372,8,32,10,32,12,32,375,9,32,1,32,1,32,1,33,1,33,1,
        33,3,33,382,8,33,1,34,1,34,1,34,1,35,1,35,1,35,5,35,390,8,35,10,
        35,12,35,393,9,35,1,36,1,36,5,36,397,8,36,10,36,12,36,400,9,36,1,
        36,1,36,1,37,3,37,405,8,37,1,37,3,37,408,8,37,1,37,1,37,1,37,3,37,
        413,8,37,1,37,3,37,416,8,37,1,37,1,37,1,38,1,38,1,38,1,38,5,38,424,
        8,38,10,38,12,38,427,9,38,1,39,1,39,5,39,431,8,39,10,39,12,39,434,
        9,39,1,39,1,39,1,40,1,40,1,41,3,41,441,8,41,1,41,3,41,444,8,41,1,
        41,1,41,1,41,3,41,449,8,41,1,41,1,41,3,41,453,8,41,1,41,1,41,1,41,
        1,42,1,42,3,42,460,8,42,1,43,1,43,1,43,3,43,465,8,43,1,43,3,43,468,
        8,43,1,44,1,44,1,44,5,44,473,8,44,10,44,12,44,476,9,44,1,45,3,45,
        479,8,45,1,45,3,45,482,8,45,1,45,1,45,1,45,1,46,1,46,1,47,3,47,490,
        8,47,1,47,1,47,1,47,1,47,1,48,1,48,3,48,498,8,48,1,49,1,49,1,49,
        1,49,1,49,5,49,505,8,49,10,49,12,49,508,9,49,1,49,1,49,3,49,512,
        8,49,1,49,1,49,5,49,516,8,49,10,49,12,49,519,9,49,1,50,4,50,522,
        8,50,11,50,12,50,523,1,51,1,51,1,51,1,51,1,52,1,52,1,52,5,52,533,
        8,52,10,52,12,52,536,9,52,1,53,1,53,1,54,4,54,541,8,54,11,54,12,
        54,542,1,55,1,55,1,56,1,56,1,56,1,56,5,56,551,8,56,10,56,12,56,554,
        9,56,1,56,1,56,1,57,1,57,1,58,1,58,1,58,0,0,59,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,0,9,12,0,23,23,25,25,28,28,33,33,
        37,37,47,47,54,54,74,74,77,77,81,81,89,90,93,93,1,0,108,110,1,0,
        106,107,1,0,2,3,1,0,114,117,1,0,112,113,2,0,6,15,111,111,4,0,53,
        53,65,65,72,72,84,84,10,0,18,20,42,42,56,56,61,61,66,66,68,71,76,
        76,80,80,92,92,95,95,580,0,118,1,0,0,0,2,126,1,0,0,0,4,137,1,0,0,
        0,6,144,1,0,0,0,8,157,1,0,0,0,10,165,1,0,0,0,12,175,1,0,0,0,14,177,
        1,0,0,0,16,185,1,0,0,0,18,193,1,0,0,0,20,201,1,0,0,0,22,209,1,0,
        0,0,24,217,1,0,0,0,26,225,1,0,0,0,28,233,1,0,0,0,30,241,1,0,0,0,
        32,245,1,0,0,0,34,252,1,0,0,0,36,254,1,0,0,0,38,257,1,0,0,0,40,268,
        1,0,0,0,42,279,1,0,0,0,44,281,1,0,0,0,46,290,1,0,0,0,48,313,1,0,
        0,0,50,323,1,0,0,0,52,325,1,0,0,0,54,331,1,0,0,0,56,339,1,0,0,0,
        58,357,1,0,0,0,60,359,1,0,0,0,62,361,1,0,0,0,64,369,1,0,0,0,66,381,
        1,0,0,0,68,383,1,0,0,0,70,386,1,0,0,0,72,398,1,0,0,0,74,404,1,0,
        0,0,76,419,1,0,0,0,78,428,1,0,0,0,80,437,1,0,0,0,82,440,1,0,0,0,
        84,459,1,0,0,0,86,467,1,0,0,0,88,469,1,0,0,0,90,478,1,0,0,0,92,486,
        1,0,0,0,94,489,1,0,0,0,96,497,1,0,0,0,98,499,1,0,0,0,100,521,1,0,
        0,0,102,525,1,0,0,0,104,529,1,0,0,0,106,537,1,0,0,0,108,540,1,0,
        0,0,110,544,1,0,0,0,112,546,1,0,0,0,114,557,1,0,0,0,116,559,1,0,
        0,0,118,119,3,6,3,0,119,122,5,99,0,0,120,121,5,111,0,0,121,123,3,
        8,4,0,122,120,1,0,0,0,122,123,1,0,0,0,123,124,1,0,0,0,124,125,5,
        125,0,0,125,1,1,0,0,0,126,127,3,98,49,0,127,132,3,0,0,0,128,129,
        5,126,0,0,129,131,3,0,0,0,130,128,1,0,0,0,131,134,1,0,0,0,132,130,
        1,0,0,0,132,133,1,0,0,0,133,135,1,0,0,0,134,132,1,0,0,0,135,136,
        5,125,0,0,136,3,1,0,0,0,137,138,5,31,0,0,138,139,3,6,3,0,139,140,
        5,99,0,0,140,141,5,111,0,0,141,142,3,8,4,0,142,143,5,125,0,0,143,
        5,1,0,0,0,144,145,7,0,0,0,145,7,1,0,0,0,146,158,3,10,5,0,147,158,
        3,12,6,0,148,158,3,14,7,0,149,158,3,16,8,0,150,158,3,18,9,0,151,
        158,3,20,10,0,152,158,3,22,11,0,153,158,3,24,12,0,154,158,3,26,13,
        0,155,158,3,28,14,0,156,158,3,30,15,0,157,146,1,0,0,0,157,147,1,
        0,0,0,157,148,1,0,0,0,157,149,1,0,0,0,157,150,1,0,0,0,157,151,1,
        0,0,0,157,152,1,0,0,0,157,153,1,0,0,0,157,154,1,0,0,0,157,155,1,
        0,0,0,157,156,1,0,0,0,158,9,1,0,0,0,159,166,5,99,0,0,160,166,3,34,
        17,0,161,162,5,121,0,0,162,163,3,8,4,0,163,164,5,122,0,0,164,166,
        1,0,0,0,165,159,1,0,0,0,165,160,1,0,0,0,165,161,1,0,0,0,166,11,1,
        0,0,0,167,168,5,106,0,0,168,176,3,12,6,0,169,170,5,107,0,0,170,176,
        3,12,6,0,171,172,5,120,0,0,172,176,3,12,6,0,173,174,5,1,0,0,174,
        176,3,12,6,0,175,167,1,0,0,0,175,169,1,0,0,0,175,171,1,0,0,0,175,
        173,1,0,0,0,176,13,1,0,0,0,177,182,3,12,6,0,178,179,7,1,0,0,179,
        181,3,12,6,0,180,178,1,0,0,0,181,184,1,0,0,0,182,180,1,0,0,0,182,
        183,1,0,0,0,183,15,1,0,0,0,184,182,1,0,0,0,185,190,3,14,7,0,186,
        187,7,2,0,0,187,189,3,14,7,0,188,186,1,0,0,0,189,192,1,0,0,0,190,
        188,1,0,0,0,190,191,1,0,0,0,191,17,1,0,0,0,192,190,1,0,0,0,193,198,
        3,16,8,0,194,195,7,3,0,0,195,197,3,16,8,0,196,194,1,0,0,0,197,200,
        1,0,0,0,198,196,1,0,0,0,198,199,1,0,0,0,199,19,1,0,0,0,200,198,1,
        0,0,0,201,206,3,18,9,0,202,203,7,4,0,0,203,205,3,18,9,0,204,202,
        1,0,0,0,205,208,1,0,0,0,206,204,1,0,0,0,206,207,1,0,0,0,207,21,1,
        0,0,0,208,206,1,0,0,0,209,214,3,20,10,0,210,211,7,5,0,0,211,213,
        3,20,10,0,212,210,1,0,0,0,213,216,1,0,0,0,214,212,1,0,0,0,214,215,
        1,0,0,0,215,23,1,0,0,0,216,214,1,0,0,0,217,222,3,22,11,0,218,219,
        5,118,0,0,219,221,3,22,11,0,220,218,1,0,0,0,221,224,1,0,0,0,222,
        220,1,0,0,0,222,223,1,0,0,0,223,25,1,0,0,0,224,222,1,0,0,0,225,230,
        3,24,12,0,226,227,5,119,0,0,227,229,3,24,12,0,228,226,1,0,0,0,229,
        232,1,0,0,0,230,228,1,0,0,0,230,231,1,0,0,0,231,27,1,0,0,0,232,230,
        1,0,0,0,233,239,3,26,13,0,234,235,5,4,0,0,235,236,3,8,4,0,236,237,
        5,5,0,0,237,238,3,8,4,0,238,240,1,0,0,0,239,234,1,0,0,0,239,240,
        1,0,0,0,240,29,1,0,0,0,241,242,5,99,0,0,242,243,3,32,16,0,243,244,
        3,8,4,0,244,31,1,0,0,0,245,246,7,6,0,0,246,33,1,0,0,0,247,253,5,
        100,0,0,248,253,5,103,0,0,249,253,3,116,58,0,250,253,3,114,57,0,
        251,253,5,102,0,0,252,247,1,0,0,0,252,248,1,0,0,0,252,249,1,0,0,
        0,252,250,1,0,0,0,252,251,1,0,0,0,253,35,1,0,0,0,254,255,9,0,0,0,
        255,256,6,18,-1,0,256,37,1,0,0,0,257,258,5,47,0,0,258,259,5,99,0,
        0,259,260,5,111,0,0,260,261,5,101,0,0,261,262,5,125,0,0,262,39,1,
        0,0,0,263,267,3,0,0,0,264,267,3,4,2,0,265,267,3,74,37,0,266,263,
        1,0,0,0,266,264,1,0,0,0,266,265,1,0,0,0,267,270,1,0,0,0,268,266,
        1,0,0,0,268,269,1,0,0,0,269,271,1,0,0,0,270,268,1,0,0,0,271,272,
        5,0,0,1,272,41,1,0,0,0,273,280,3,44,22,0,274,280,3,46,23,0,275,280,
        3,52,26,0,276,280,3,54,27,0,277,280,3,56,28,0,278,280,3,62,31,0,
        279,273,1,0,0,0,279,274,1,0,0,0,279,275,1,0,0,0,279,276,1,0,0,0,
        279,277,1,0,0,0,279,278,1,0,0,0,280,43,1,0,0,0,281,282,5,51,0,0,
        282,283,5,121,0,0,283,284,3,8,4,0,284,285,5,122,0,0,285,288,3,64,
        32,0,286,287,5,38,0,0,287,289,3,64,32,0,288,286,1,0,0,0,288,289,
        1,0,0,0,289,45,1,0,0,0,290,291,5,83,0,0,291,292,5,121,0,0,292,293,
        3,8,4,0,293,294,5,122,0,0,294,296,5,123,0,0,295,297,3,48,24,0,296,
        295,1,0,0,0,297,298,1,0,0,0,298,296,1,0,0,0,298,299,1,0,0,0,299,
        300,1,0,0,0,300,301,5,124,0,0,301,47,1,0,0,0,302,304,3,50,25,0,303,
        302,1,0,0,0,304,305,1,0,0,0,305,303,1,0,0,0,305,306,1,0,0,0,306,
        310,1,0,0,0,307,309,3,66,33,0,308,307,1,0,0,0,309,312,1,0,0,0,310,
        308,1,0,0,0,310,311,1,0,0,0,311,314,1,0,0,0,312,310,1,0,0,0,313,
        303,1,0,0,0,314,315,1,0,0,0,315,313,1,0,0,0,315,316,1,0,0,0,316,
        49,1,0,0,0,317,318,5,26,0,0,318,319,3,8,4,0,319,320,5,5,0,0,320,
        324,1,0,0,0,321,322,5,34,0,0,322,324,5,5,0,0,323,317,1,0,0,0,323,
        321,1,0,0,0,324,51,1,0,0,0,325,326,5,98,0,0,326,327,5,121,0,0,327,
        328,3,8,4,0,328,329,5,122,0,0,329,330,3,64,32,0,330,53,1,0,0,0,331,
        332,5,36,0,0,332,333,3,64,32,0,333,334,5,98,0,0,334,335,5,121,0,
        0,335,336,3,8,4,0,336,337,5,122,0,0,337,338,5,125,0,0,338,55,1,0,
        0,0,339,340,5,48,0,0,340,342,5,121,0,0,341,343,3,58,29,0,342,341,
        1,0,0,0,342,343,1,0,0,0,343,344,1,0,0,0,344,346,5,125,0,0,345,347,
        3,8,4,0,346,345,1,0,0,0,346,347,1,0,0,0,347,348,1,0,0,0,348,350,
        5,125,0,0,349,351,3,60,30,0,350,349,1,0,0,0,350,351,1,0,0,0,351,
        352,1,0,0,0,352,353,5,122,0,0,353,354,3,64,32,0,354,57,1,0,0,0,355,
        358,3,2,1,0,356,358,3,70,35,0,357,355,1,0,0,0,357,356,1,0,0,0,358,
        59,1,0,0,0,359,360,3,70,35,0,360,61,1,0,0,0,361,362,5,49,0,0,362,
        363,5,121,0,0,363,364,3,6,3,0,364,365,5,53,0,0,365,366,3,8,4,0,366,
        367,5,122,0,0,367,368,3,64,32,0,368,63,1,0,0,0,369,373,5,123,0,0,
        370,372,3,66,33,0,371,370,1,0,0,0,372,375,1,0,0,0,373,371,1,0,0,
        0,373,374,1,0,0,0,374,376,1,0,0,0,375,373,1,0,0,0,376,377,5,124,
        0,0,377,65,1,0,0,0,378,382,3,42,21,0,379,382,3,68,34,0,380,382,3,
        64,32,0,381,378,1,0,0,0,381,379,1,0,0,0,381,380,1,0,0,0,382,67,1,
        0,0,0,383,384,3,8,4,0,384,385,5,125,0,0,385,69,1,0,0,0,386,391,3,
        8,4,0,387,388,5,126,0,0,388,390,3,8,4,0,389,387,1,0,0,0,390,393,
        1,0,0,0,391,389,1,0,0,0,391,392,1,0,0,0,392,71,1,0,0,0,393,391,1,
        0,0,0,394,397,3,74,37,0,395,397,3,82,41,0,396,394,1,0,0,0,396,395,
        1,0,0,0,397,400,1,0,0,0,398,396,1,0,0,0,398,399,1,0,0,0,399,401,
        1,0,0,0,400,398,1,0,0,0,401,402,5,0,0,1,402,73,1,0,0,0,403,405,3,
        100,50,0,404,403,1,0,0,0,404,405,1,0,0,0,405,407,1,0,0,0,406,408,
        3,108,54,0,407,406,1,0,0,0,407,408,1,0,0,0,408,409,1,0,0,0,409,410,
        5,30,0,0,410,412,5,99,0,0,411,413,3,112,56,0,412,411,1,0,0,0,412,
        413,1,0,0,0,413,415,1,0,0,0,414,416,3,76,38,0,415,414,1,0,0,0,415,
        416,1,0,0,0,416,417,1,0,0,0,417,418,3,78,39,0,418,75,1,0,0,0,419,
        420,5,5,0,0,420,425,3,98,49,0,421,422,5,126,0,0,422,424,3,98,49,
        0,423,421,1,0,0,0,424,427,1,0,0,0,425,423,1,0,0,0,425,426,1,0,0,
        0,426,77,1,0,0,0,427,425,1,0,0,0,428,432,5,123,0,0,429,431,3,80,
        40,0,430,429,1,0,0,0,431,434,1,0,0,0,432,430,1,0,0,0,432,433,1,0,
        0,0,433,435,1,0,0,0,434,432,1,0,0,0,435,436,5,124,0,0,436,79,1,0,
        0,0,437,438,3,82,41,0,438,81,1,0,0,0,439,441,3,100,50,0,440,439,
        1,0,0,0,440,441,1,0,0,0,441,443,1,0,0,0,442,444,3,108,54,0,443,442,
        1,0,0,0,443,444,1,0,0,0,444,445,1,0,0,0,445,446,3,84,42,0,446,448,
        5,99,0,0,447,449,3,112,56,0,448,447,1,0,0,0,448,449,1,0,0,0,449,
        450,1,0,0,0,450,452,5,121,0,0,451,453,3,86,43,0,452,451,1,0,0,0,
        452,453,1,0,0,0,453,454,1,0,0,0,454,455,5,122,0,0,455,456,3,96,48,
        0,456,83,1,0,0,0,457,460,3,98,49,0,458,460,5,96,0,0,459,457,1,0,
        0,0,459,458,1,0,0,0,460,85,1,0,0,0,461,464,3,88,44,0,462,463,5,126,
        0,0,463,465,3,94,47,0,464,462,1,0,0,0,464,465,1,0,0,0,465,468,1,
        0,0,0,466,468,3,94,47,0,467,461,1,0,0,0,467,466,1,0,0,0,468,87,1,
        0,0,0,469,474,3,90,45,0,470,471,5,126,0,0,471,473,3,90,45,0,472,
        470,1,0,0,0,473,476,1,0,0,0,474,472,1,0,0,0,474,475,1,0,0,0,475,
        89,1,0,0,0,476,474,1,0,0,0,477,479,3,100,50,0,478,477,1,0,0,0,478,
        479,1,0,0,0,479,481,1,0,0,0,480,482,3,92,46,0,481,480,1,0,0,0,481,
        482,1,0,0,0,482,483,1,0,0,0,483,484,3,98,49,0,484,485,5,99,0,0,485,
        91,1,0,0,0,486,487,7,7,0,0,487,93,1,0,0,0,488,490,3,100,50,0,489,
        488,1,0,0,0,489,490,1,0,0,0,490,491,1,0,0,0,491,492,5,67,0,0,492,
        493,3,98,49,0,493,494,5,99,0,0,494,95,1,0,0,0,495,498,3,64,32,0,
        496,498,5,125,0,0,497,495,1,0,0,0,497,496,1,0,0,0,498,97,1,0,0,0,
        499,511,5,99,0,0,500,501,5,115,0,0,501,506,3,98,49,0,502,503,5,126,
        0,0,503,505,3,98,49,0,504,502,1,0,0,0,505,508,1,0,0,0,506,504,1,
        0,0,0,506,507,1,0,0,0,507,509,1,0,0,0,508,506,1,0,0,0,509,510,5,
        114,0,0,510,512,1,0,0,0,511,500,1,0,0,0,511,512,1,0,0,0,512,517,
        1,0,0,0,513,514,5,16,0,0,514,516,5,17,0,0,515,513,1,0,0,0,516,519,
        1,0,0,0,517,515,1,0,0,0,517,518,1,0,0,0,518,99,1,0,0,0,519,517,1,
        0,0,0,520,522,3,102,51,0,521,520,1,0,0,0,522,523,1,0,0,0,523,521,
        1,0,0,0,523,524,1,0,0,0,524,101,1,0,0,0,525,526,5,16,0,0,526,527,
        3,104,52,0,527,528,5,17,0,0,528,103,1,0,0,0,529,534,3,106,53,0,530,
        531,5,126,0,0,531,533,3,106,53,0,532,530,1,0,0,0,533,536,1,0,0,0,
        534,532,1,0,0,0,534,535,1,0,0,0,535,105,1,0,0,0,536,534,1,0,0,0,
        537,538,5,99,0,0,538,107,1,0,0,0,539,541,3,110,55,0,540,539,1,0,
        0,0,541,542,1,0,0,0,542,540,1,0,0,0,542,543,1,0,0,0,543,109,1,0,
        0,0,544,545,7,8,0,0,545,111,1,0,0,0,546,547,5,115,0,0,547,552,5,
        99,0,0,548,549,5,126,0,0,549,551,5,99,0,0,550,548,1,0,0,0,551,554,
        1,0,0,0,552,550,1,0,0,0,552,553,1,0,0,0,553,555,1,0,0,0,554,552,
        1,0,0,0,555,556,5,114,0,0,556,113,1,0,0,0,557,558,5,104,0,0,558,
        115,1,0,0,0,559,560,5,105,0,0,560,117,1,0,0,0,57,122,132,157,165,
        175,182,190,198,206,214,222,230,239,252,266,268,279,288,298,305,
        310,315,323,342,346,350,357,373,381,391,396,398,404,407,412,415,
        425,432,440,443,448,452,459,464,467,474,478,481,489,497,506,511,
        517,523,534,542,552
    ]

class CSharpLexerParser ( Parser ):

    grammarFileName = "CSharpLexer.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'~'", "'<<'", "'>>'", "'?'", "':'", "'+='", 
                     "'-='", "'*='", "'/='", "'%='", "'&='", "'|='", "'^='", 
                     "'<<='", "'>>='", "'['", "']'", "'partial'", "'async'", 
                     "'abstract'", "'as'", "'base'", "'bool'", "'break'", 
                     "'byte'", "'case'", "'catch'", "'char'", "'checked'", 
                     "'class'", "'const'", "'continue'", "'decimal'", "'default'", 
                     "'delegate'", "'do'", "'double'", "'else'", "'enum'", 
                     "'event'", "'explicit'", "'extern'", "'false'", "'file'", 
                     "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", 
                     "'goto'", "'if'", "'implicit'", "'in'", "'int'", "'interface'", 
                     "'internal'", "'is'", "'lock'", "'long'", "'namespace'", 
                     "'new'", "'null'", "'object'", "'operator'", "'out'", 
                     "'override'", "'params'", "'private'", "'protected'", 
                     "'public'", "'readonly'", "'ref'", "'return'", "'sbyte'", 
                     "'scoped'", "'sealed'", "'short'", "'sizeof'", "'stackalloc'", 
                     "'static'", "'string'", "'struct'", "'switch'", "'this'", 
                     "'throw'", "'true'", "'try'", "'typeof'", "'uint'", 
                     "'ulong'", "'unchecked'", "'unsafe'", "'ushort'", "'using'", 
                     "'virtual'", "'void'", "'volatile'", "'while'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'+'", "'-'", "'*'", "'/'", 
                     "'%'", "'='", "'=='", "'!='", "'>'", "'<'", "'>='", 
                     "'<='", "'&&'", "'||'", "'!'", "'('", "')'", "'{'", 
                     "'}'", "';'", "','", "'.'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "ABSTRACT", "AS", "BASE", "BOOL", "BREAK", "BYTE", 
                      "CASE", "CATCH", "CHAR", "CHECKED", "CLASS", "CONST", 
                      "CONTINUE", "DECIMAL", "DEFAULT", "DELEGATE", "DO", 
                      "DOUBLE", "ELSE", "ENUM", "EVENT", "EXPLICIT", "EXTERN", 
                      "FALSE", "FILE", "FINALLY", "FIXED", "FLOAT", "FOR", 
                      "FOREACH", "GOTO", "IF", "IMPLICIT", "IN", "INT", 
                      "INTERFACE", "INTERNAL", "IS", "LOCK", "LONG", "NAMESPACE", 
                      "NEW", "NULL", "OBJECT", "OPERATOR", "OUT", "OVERRIDE", 
                      "PARAMS", "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", 
                      "REF", "RETURN", "SBYTE", "SCOPED", "SEALED", "SHORT", 
                      "SIZEOF", "STACKALLOC", "STATIC", "STRING", "STRUCT", 
                      "SWITCH", "THIS", "THROW", "TRUE", "TRY", "TYPEOF", 
                      "UINT", "ULONG", "UNCHECKED", "UNSAFE", "USHORT", 
                      "USING", "VIRTUAL", "VOID", "VOLATILE", "WHILE", "IDENTIFIER", 
                      "INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", 
                      "STRING_LITERAL", "NULL_LITERAL", "BOOL_LITERAL", 
                      "ADD", "SUB", "MUL", "DIV", "MOD", "ASSING", "EQUALS", 
                      "NOTEQUALS", "BIGGERTHAN", "LESSTHAN", "BOET", "LOET", 
                      "AND", "OR", "NOT", "LPAREN", "RPAREN", "LBRACE", 
                      "RBRACE", "SEMI", "COMMA", "PUNTO", "WS", "LINE_COMMENT", 
                      "BLOCK_COMMENT" ]

    RULE_variable_declaration = 0
    RULE_localVariableDeclaration = 1
    RULE_constant_declaration = 2
    RULE_type_identifier = 3
    RULE_expression = 4
    RULE_primary_expression = 5
    RULE_unary_expression = 6
    RULE_multiplicative_expression = 7
    RULE_additive_expression = 8
    RULE_shift_expression = 9
    RULE_relational_expression = 10
    RULE_equality_expression = 11
    RULE_logical_and_expression = 12
    RULE_logical_or_expression = 13
    RULE_conditional_expression = 14
    RULE_assignment_expression = 15
    RULE_assignment_operator = 16
    RULE_literal = 17
    RULE_error = 18
    RULE_float_declaration = 19
    RULE_prog = 20
    RULE_controlStructure = 21
    RULE_ifStatement = 22
    RULE_switchStatement = 23
    RULE_switchSection = 24
    RULE_caseLabel = 25
    RULE_whileStatement = 26
    RULE_doWhileStatement = 27
    RULE_forStatement = 28
    RULE_forInitializer = 29
    RULE_forIterator = 30
    RULE_foreachStatement = 31
    RULE_block = 32
    RULE_statement = 33
    RULE_expressionStatement = 34
    RULE_expressionList = 35
    RULE_compilationUnit = 36
    RULE_classDeclaration = 37
    RULE_classBase = 38
    RULE_classBody = 39
    RULE_classMemberDeclaration = 40
    RULE_methodDeclaration = 41
    RULE_returnType = 42
    RULE_formalParameterList = 43
    RULE_fixedParameters = 44
    RULE_fixedParameter = 45
    RULE_parameterModifier = 46
    RULE_parameterArray = 47
    RULE_methodBody = 48
    RULE_type = 49
    RULE_attributes = 50
    RULE_attributeSection = 51
    RULE_attributeList = 52
    RULE_attribute = 53
    RULE_modifiers = 54
    RULE_modifier = 55
    RULE_typeParameters = 56
    RULE_null_literal = 57
    RULE_boolean_literal = 58

    ruleNames =  [ "variable_declaration", "localVariableDeclaration", "constant_declaration", 
                   "type_identifier", "expression", "primary_expression", 
                   "unary_expression", "multiplicative_expression", "additive_expression", 
                   "shift_expression", "relational_expression", "equality_expression", 
                   "logical_and_expression", "logical_or_expression", "conditional_expression", 
                   "assignment_expression", "assignment_operator", "literal", 
                   "error", "float_declaration", "prog", "controlStructure", 
                   "ifStatement", "switchStatement", "switchSection", "caseLabel", 
                   "whileStatement", "doWhileStatement", "forStatement", 
                   "forInitializer", "forIterator", "foreachStatement", 
                   "block", "statement", "expressionStatement", "expressionList", 
                   "compilationUnit", "classDeclaration", "classBase", "classBody", 
                   "classMemberDeclaration", "methodDeclaration", "returnType", 
                   "formalParameterList", "fixedParameters", "fixedParameter", 
                   "parameterModifier", "parameterArray", "methodBody", 
                   "type", "attributes", "attributeSection", "attributeList", 
                   "attribute", "modifiers", "modifier", "typeParameters", 
                   "null_literal", "boolean_literal" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    ABSTRACT=20
    AS=21
    BASE=22
    BOOL=23
    BREAK=24
    BYTE=25
    CASE=26
    CATCH=27
    CHAR=28
    CHECKED=29
    CLASS=30
    CONST=31
    CONTINUE=32
    DECIMAL=33
    DEFAULT=34
    DELEGATE=35
    DO=36
    DOUBLE=37
    ELSE=38
    ENUM=39
    EVENT=40
    EXPLICIT=41
    EXTERN=42
    FALSE=43
    FILE=44
    FINALLY=45
    FIXED=46
    FLOAT=47
    FOR=48
    FOREACH=49
    GOTO=50
    IF=51
    IMPLICIT=52
    IN=53
    INT=54
    INTERFACE=55
    INTERNAL=56
    IS=57
    LOCK=58
    LONG=59
    NAMESPACE=60
    NEW=61
    NULL=62
    OBJECT=63
    OPERATOR=64
    OUT=65
    OVERRIDE=66
    PARAMS=67
    PRIVATE=68
    PROTECTED=69
    PUBLIC=70
    READONLY=71
    REF=72
    RETURN=73
    SBYTE=74
    SCOPED=75
    SEALED=76
    SHORT=77
    SIZEOF=78
    STACKALLOC=79
    STATIC=80
    STRING=81
    STRUCT=82
    SWITCH=83
    THIS=84
    THROW=85
    TRUE=86
    TRY=87
    TYPEOF=88
    UINT=89
    ULONG=90
    UNCHECKED=91
    UNSAFE=92
    USHORT=93
    USING=94
    VIRTUAL=95
    VOID=96
    VOLATILE=97
    WHILE=98
    IDENTIFIER=99
    INTEGER_LITERAL=100
    REAL_LITERAL=101
    CHARACTER_LITERAL=102
    STRING_LITERAL=103
    NULL_LITERAL=104
    BOOL_LITERAL=105
    ADD=106
    SUB=107
    MUL=108
    DIV=109
    MOD=110
    ASSING=111
    EQUALS=112
    NOTEQUALS=113
    BIGGERTHAN=114
    LESSTHAN=115
    BOET=116
    LOET=117
    AND=118
    OR=119
    NOT=120
    LPAREN=121
    RPAREN=122
    LBRACE=123
    RBRACE=124
    SEMI=125
    COMMA=126
    PUNTO=127
    WS=128
    LINE_COMMENT=129
    BLOCK_COMMENT=130

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




    class Variable_declarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def type_identifier(self):
            return self.getTypedRuleContext(CSharpLexerParser.Type_identifierContext,0)


        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

        def ASSING(self):
            return self.getToken(CSharpLexerParser.ASSING, 0)

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


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_variable_declaration

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

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

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




    def variable_declaration(self):

        localctx = CSharpLexerParser.Variable_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_variable_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 118
            self.type_identifier()
            self.state = 119
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 122
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==111:
                self.state = 120
                self.match(CSharpLexerParser.ASSING)
                self.state = 121
                self.expression()


            self.state = 124
            self.match(CSharpLexerParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LocalVariableDeclarationContext(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(CSharpLexerParser.TypeContext,0)


        def variable_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.Variable_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Variable_declarationContext,i)


        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_localVariableDeclaration

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

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

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




    def localVariableDeclaration(self):

        localctx = CSharpLexerParser.LocalVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_localVariableDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 126
            self.type_()
            self.state = 127
            self.variable_declaration()
            self.state = 132
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==126:
                self.state = 128
                self.match(CSharpLexerParser.COMMA)
                self.state = 129
                self.variable_declaration()
                self.state = 134
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 135
            self.match(CSharpLexerParser.SEMI)
        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(CSharpLexerParser.CONST, 0)

        def type_identifier(self):
            return self.getTypedRuleContext(CSharpLexerParser.Type_identifierContext,0)


        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def ASSING(self):
            return self.getToken(CSharpLexerParser.ASSING, 0)

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


        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConstant_declaration" ):
                return visitor.visitConstant_declaration(self)
            else:
                return visitor.visitChildren(self)




    def constant_declaration(self):

        localctx = CSharpLexerParser.Constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_constant_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 137
            self.match(CSharpLexerParser.CONST)
            self.state = 138
            self.type_identifier()
            self.state = 139
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 140
            self.match(CSharpLexerParser.ASSING)
            self.state = 141
            self.expression()
            self.state = 142
            self.match(CSharpLexerParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_identifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_type_identifier

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

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

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




    def type_identifier(self):

        localctx = CSharpLexerParser.Type_identifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_type_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 144
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 18155282337103872) != 0) or ((((_la - 74)) & ~0x3f) == 0 and ((1 << (_la - 74)) & 622729) != 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 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(CSharpLexerParser.Primary_expressionContext,0)


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


        def multiplicative_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Multiplicative_expressionContext,0)


        def additive_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Additive_expressionContext,0)


        def shift_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Shift_expressionContext,0)


        def relational_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Relational_expressionContext,0)


        def equality_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Equality_expressionContext,0)


        def logical_and_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Logical_and_expressionContext,0)


        def logical_or_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Logical_or_expressionContext,0)


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


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


        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExpression" ):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)




    def expression(self):

        localctx = CSharpLexerParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_expression)
        try:
            self.state = 157
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 146
                self.primary_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 147
                self.unary_expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 148
                self.multiplicative_expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 149
                self.additive_expression()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 150
                self.shift_expression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 151
                self.relational_expression()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 152
                self.equality_expression()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 153
                self.logical_and_expression()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 154
                self.logical_or_expression()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 155
                self.conditional_expression()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 156
                self.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 Primary_expressionContext(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(CSharpLexerParser.IDENTIFIER, 0)

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


        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPrimary_expression" ):
                return visitor.visitPrimary_expression(self)
            else:
                return visitor.visitChildren(self)




    def primary_expression(self):

        localctx = CSharpLexerParser.Primary_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_primary_expression)
        try:
            self.state = 165
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [99]:
                self.enterOuterAlt(localctx, 1)
                self.state = 159
                self.match(CSharpLexerParser.IDENTIFIER)
                pass
            elif token in [100, 102, 103, 104, 105]:
                self.enterOuterAlt(localctx, 2)
                self.state = 160
                self.literal()
                pass
            elif token in [121]:
                self.enterOuterAlt(localctx, 3)
                self.state = 161
                self.match(CSharpLexerParser.LPAREN)
                self.state = 162
                self.expression()
                self.state = 163
                self.match(CSharpLexerParser.RPAREN)
                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 Unary_expressionContext(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(CSharpLexerParser.ADD, 0)

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


        def SUB(self):
            return self.getToken(CSharpLexerParser.SUB, 0)

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

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitUnary_expression" ):
                return visitor.visitUnary_expression(self)
            else:
                return visitor.visitChildren(self)




    def unary_expression(self):

        localctx = CSharpLexerParser.Unary_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_unary_expression)
        try:
            self.state = 175
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [106]:
                self.enterOuterAlt(localctx, 1)
                self.state = 167
                self.match(CSharpLexerParser.ADD)
                self.state = 168
                self.unary_expression()
                pass
            elif token in [107]:
                self.enterOuterAlt(localctx, 2)
                self.state = 169
                self.match(CSharpLexerParser.SUB)
                self.state = 170
                self.unary_expression()
                pass
            elif token in [120]:
                self.enterOuterAlt(localctx, 3)
                self.state = 171
                self.match(CSharpLexerParser.NOT)
                self.state = 172
                self.unary_expression()
                pass
            elif token in [1]:
                self.enterOuterAlt(localctx, 4)
                self.state = 173
                self.match(CSharpLexerParser.T__0)
                self.state = 174
                self.unary_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 Multiplicative_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(CSharpLexerParser.Unary_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Unary_expressionContext,i)


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

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

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

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMultiplicative_expression" ):
                return visitor.visitMultiplicative_expression(self)
            else:
                return visitor.visitChildren(self)




    def multiplicative_expression(self):

        localctx = CSharpLexerParser.Multiplicative_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_multiplicative_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self.unary_expression()
            self.state = 182
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 7) != 0):
                self.state = 178
                _la = self._input.LA(1)
                if not(((((_la - 108)) & ~0x3f) == 0 and ((1 << (_la - 108)) & 7) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 179
                self.unary_expression()
                self.state = 184
                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 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(CSharpLexerParser.Multiplicative_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Multiplicative_expressionContext,i)


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

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

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAdditive_expression" ):
                return visitor.visitAdditive_expression(self)
            else:
                return visitor.visitChildren(self)




    def additive_expression(self):

        localctx = CSharpLexerParser.Additive_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_additive_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 185
            self.multiplicative_expression()
            self.state = 190
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==106 or _la==107:
                self.state = 186
                _la = self._input.LA(1)
                if not(_la==106 or _la==107):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 187
                self.multiplicative_expression()
                self.state = 192
                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 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(CSharpLexerParser.Additive_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Additive_expressionContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitShift_expression" ):
                return visitor.visitShift_expression(self)
            else:
                return visitor.visitChildren(self)




    def shift_expression(self):

        localctx = CSharpLexerParser.Shift_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_shift_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 193
            self.additive_expression()
            self.state = 198
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2 or _la==3:
                self.state = 194
                _la = self._input.LA(1)
                if not(_la==2 or _la==3):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 195
                self.additive_expression()
                self.state = 200
                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 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(CSharpLexerParser.Shift_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Shift_expressionContext,i)


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

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

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

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

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitRelational_expression" ):
                return visitor.visitRelational_expression(self)
            else:
                return visitor.visitChildren(self)




    def relational_expression(self):

        localctx = CSharpLexerParser.Relational_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_relational_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 201
            self.shift_expression()
            self.state = 206
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while ((((_la - 114)) & ~0x3f) == 0 and ((1 << (_la - 114)) & 15) != 0):
                self.state = 202
                _la = self._input.LA(1)
                if not(((((_la - 114)) & ~0x3f) == 0 and ((1 << (_la - 114)) & 15) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 203
                self.shift_expression()
                self.state = 208
                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 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(CSharpLexerParser.Relational_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Relational_expressionContext,i)


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

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

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEquality_expression" ):
                return visitor.visitEquality_expression(self)
            else:
                return visitor.visitChildren(self)




    def equality_expression(self):

        localctx = CSharpLexerParser.Equality_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_equality_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 209
            self.relational_expression()
            self.state = 214
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==112 or _la==113:
                self.state = 210
                _la = self._input.LA(1)
                if not(_la==112 or _la==113):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 211
                self.relational_expression()
                self.state = 216
                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 Logical_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(CSharpLexerParser.Equality_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Equality_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_logical_and_expression

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

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

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




    def logical_and_expression(self):

        localctx = CSharpLexerParser.Logical_and_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_logical_and_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 217
            self.equality_expression()
            self.state = 222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==118:
                self.state = 218
                self.match(CSharpLexerParser.AND)
                self.state = 219
                self.equality_expression()
                self.state = 224
                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 Logical_or_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def logical_and_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.Logical_and_expressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Logical_and_expressionContext,i)


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_logical_or_expression

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

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

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




    def logical_or_expression(self):

        localctx = CSharpLexerParser.Logical_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_logical_or_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self.logical_and_expression()
            self.state = 230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==119:
                self.state = 226
                self.match(CSharpLexerParser.OR)
                self.state = 227
                self.logical_and_expression()
                self.state = 232
                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 Conditional_expressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def logical_or_expression(self):
            return self.getTypedRuleContext(CSharpLexerParser.Logical_or_expressionContext,0)


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


        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitConditional_expression" ):
                return visitor.visitConditional_expression(self)
            else:
                return visitor.visitChildren(self)




    def conditional_expression(self):

        localctx = CSharpLexerParser.Conditional_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_conditional_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 233
            self.logical_or_expression()
            self.state = 239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==4:
                self.state = 234
                self.match(CSharpLexerParser.T__3)
                self.state = 235
                self.expression()
                self.state = 236
                self.match(CSharpLexerParser.T__4)
                self.state = 237
                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 Assignment_expressionContext(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(CSharpLexerParser.IDENTIFIER, 0)

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


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


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_assignment_expression

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

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

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




    def assignment_expression(self):

        localctx = CSharpLexerParser.Assignment_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_assignment_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 241
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 242
            self.assignment_operator()
            self.state = 243
            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 Assignment_operatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ASSING(self):
            return self.getToken(CSharpLexerParser.ASSING, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignment_operator" ):
                return visitor.visitAssignment_operator(self)
            else:
                return visitor.visitChildren(self)




    def assignment_operator(self):

        localctx = CSharpLexerParser.Assignment_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_assignment_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 245
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 65472) != 0) or _la==111):
                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 LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INTEGER_LITERAL(self):
            return self.getToken(CSharpLexerParser.INTEGER_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(CSharpLexerParser.STRING_LITERAL, 0)

        def boolean_literal(self):
            return self.getTypedRuleContext(CSharpLexerParser.Boolean_literalContext,0)


        def null_literal(self):
            return self.getTypedRuleContext(CSharpLexerParser.Null_literalContext,0)


        def CHARACTER_LITERAL(self):
            return self.getToken(CSharpLexerParser.CHARACTER_LITERAL, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral" ):
                return visitor.visitLiteral(self)
            else:
                return visitor.visitChildren(self)




    def literal(self):

        localctx = CSharpLexerParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_literal)
        try:
            self.state = 252
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [100]:
                self.enterOuterAlt(localctx, 1)
                self.state = 247
                self.match(CSharpLexerParser.INTEGER_LITERAL)
                pass
            elif token in [103]:
                self.enterOuterAlt(localctx, 2)
                self.state = 248
                self.match(CSharpLexerParser.STRING_LITERAL)
                pass
            elif token in [105]:
                self.enterOuterAlt(localctx, 3)
                self.state = 249
                self.boolean_literal()
                pass
            elif token in [104]:
                self.enterOuterAlt(localctx, 4)
                self.state = 250
                self.null_literal()
                pass
            elif token in [102]:
                self.enterOuterAlt(localctx, 5)
                self.state = 251
                self.match(CSharpLexerParser.CHARACTER_LITERAL)
                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 ErrorContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_error

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

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

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




    def error(self):

        localctx = CSharpLexerParser.ErrorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_error)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 254
            self.matchWildcard()
            reportError(this);
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Float_declarationContext(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(CSharpLexerParser.FLOAT, 0)

        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def ASSING(self):
            return self.getToken(CSharpLexerParser.ASSING, 0)

        def REAL_LITERAL(self):
            return self.getToken(CSharpLexerParser.REAL_LITERAL, 0)

        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_float_declaration

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

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

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




    def float_declaration(self):

        localctx = CSharpLexerParser.Float_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_float_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 257
            self.match(CSharpLexerParser.FLOAT)
            self.state = 258
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 259
            self.match(CSharpLexerParser.ASSING)
            self.state = 260
            self.match(CSharpLexerParser.REAL_LITERAL)
            self.state = 261
            self.match(CSharpLexerParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ProgContext(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(CSharpLexerParser.EOF, 0)

        def variable_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.Variable_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Variable_declarationContext,i)


        def constant_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.Constant_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.Constant_declarationContext,i)


        def classDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.ClassDeclarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.ClassDeclarationContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_prog

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

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

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




    def prog(self):

        localctx = CSharpLexerParser.ProgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_prog)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 268
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2396060286858362880) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 763415869) != 0):
                self.state = 266
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [23, 25, 28, 33, 37, 47, 54, 74, 77, 81, 89, 90, 93]:
                    self.state = 263
                    self.variable_declaration()
                    pass
                elif token in [31]:
                    self.state = 264
                    self.constant_declaration()
                    pass
                elif token in [16, 18, 19, 20, 30, 42, 56, 61, 66, 68, 69, 70, 71, 76, 80, 92, 95]:
                    self.state = 265
                    self.classDeclaration()
                    pass
                else:
                    raise NoViableAltException(self)

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

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


    class ControlStructureContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ifStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.IfStatementContext,0)


        def switchStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.SwitchStatementContext,0)


        def whileStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.WhileStatementContext,0)


        def doWhileStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.DoWhileStatementContext,0)


        def forStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.ForStatementContext,0)


        def foreachStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.ForeachStatementContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_controlStructure

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

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

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




    def controlStructure(self):

        localctx = CSharpLexerParser.ControlStructureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_controlStructure)
        try:
            self.state = 279
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [51]:
                self.enterOuterAlt(localctx, 1)
                self.state = 273
                self.ifStatement()
                pass
            elif token in [83]:
                self.enterOuterAlt(localctx, 2)
                self.state = 274
                self.switchStatement()
                pass
            elif token in [98]:
                self.enterOuterAlt(localctx, 3)
                self.state = 275
                self.whileStatement()
                pass
            elif token in [36]:
                self.enterOuterAlt(localctx, 4)
                self.state = 276
                self.doWhileStatement()
                pass
            elif token in [48]:
                self.enterOuterAlt(localctx, 5)
                self.state = 277
                self.forStatement()
                pass
            elif token in [49]:
                self.enterOuterAlt(localctx, 6)
                self.state = 278
                self.foreachStatement()
                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 IfStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

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


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_ifStatement

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

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

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




    def ifStatement(self):

        localctx = CSharpLexerParser.IfStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_ifStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 281
            self.match(CSharpLexerParser.IF)
            self.state = 282
            self.match(CSharpLexerParser.LPAREN)
            self.state = 283
            self.expression()
            self.state = 284
            self.match(CSharpLexerParser.RPAREN)
            self.state = 285
            self.block()
            self.state = 288
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==38:
                self.state = 286
                self.match(CSharpLexerParser.ELSE)
                self.state = 287
                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 SwitchStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

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

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

        def switchSection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.SwitchSectionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.SwitchSectionContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_switchStatement

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

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

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




    def switchStatement(self):

        localctx = CSharpLexerParser.SwitchStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_switchStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 290
            self.match(CSharpLexerParser.SWITCH)
            self.state = 291
            self.match(CSharpLexerParser.LPAREN)
            self.state = 292
            self.expression()
            self.state = 293
            self.match(CSharpLexerParser.RPAREN)
            self.state = 294
            self.match(CSharpLexerParser.LBRACE)
            self.state = 296 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 295
                self.switchSection()
                self.state = 298 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==26 or _la==34):
                    break

            self.state = 300
            self.match(CSharpLexerParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SwitchSectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def caseLabel(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.CaseLabelContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.CaseLabelContext,i)


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


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_switchSection

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

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

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




    def switchSection(self):

        localctx = CSharpLexerParser.SwitchSectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_switchSection)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 313 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 303 
                    self._errHandler.sync(self)
                    _alt = 1
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt == 1:
                            self.state = 302
                            self.caseLabel()

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

                    self.state = 310
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3096293463293954) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & 1511861747713) != 0):
                        self.state = 307
                        self.statement()
                        self.state = 312
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)


                else:
                    raise NoViableAltException(self)
                self.state = 315 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,21,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 CaseLabelContext(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(CSharpLexerParser.CASE, 0)

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


        def DEFAULT(self):
            return self.getToken(CSharpLexerParser.DEFAULT, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_caseLabel

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

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

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




    def caseLabel(self):

        localctx = CSharpLexerParser.CaseLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_caseLabel)
        try:
            self.state = 323
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [26]:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self.match(CSharpLexerParser.CASE)
                self.state = 318
                self.expression()
                self.state = 319
                self.match(CSharpLexerParser.T__4)
                pass
            elif token in [34]:
                self.enterOuterAlt(localctx, 2)
                self.state = 321
                self.match(CSharpLexerParser.DEFAULT)
                self.state = 322
                self.match(CSharpLexerParser.T__4)
                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 WhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

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


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_whileStatement

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

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

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




    def whileStatement(self):

        localctx = CSharpLexerParser.WhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_whileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 325
            self.match(CSharpLexerParser.WHILE)
            self.state = 326
            self.match(CSharpLexerParser.LPAREN)
            self.state = 327
            self.expression()
            self.state = 328
            self.match(CSharpLexerParser.RPAREN)
            self.state = 329
            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 DoWhileStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DO(self):
            return self.getToken(CSharpLexerParser.DO, 0)

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


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

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

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


        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_doWhileStatement

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

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

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




    def doWhileStatement(self):

        localctx = CSharpLexerParser.DoWhileStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_doWhileStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 331
            self.match(CSharpLexerParser.DO)
            self.state = 332
            self.block()
            self.state = 333
            self.match(CSharpLexerParser.WHILE)
            self.state = 334
            self.match(CSharpLexerParser.LPAREN)
            self.state = 335
            self.expression()
            self.state = 336
            self.match(CSharpLexerParser.RPAREN)
            self.state = 337
            self.match(CSharpLexerParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

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

        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

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


        def forInitializer(self):
            return self.getTypedRuleContext(CSharpLexerParser.ForInitializerContext,0)


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


        def forIterator(self):
            return self.getTypedRuleContext(CSharpLexerParser.ForIteratorContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_forStatement

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

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

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




    def forStatement(self):

        localctx = CSharpLexerParser.ForStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_forStatement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.match(CSharpLexerParser.FOR)
            self.state = 340
            self.match(CSharpLexerParser.LPAREN)
            self.state = 342
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==1 or ((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 6291963) != 0):
                self.state = 341
                self.forInitializer()


            self.state = 344
            self.match(CSharpLexerParser.SEMI)
            self.state = 346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==1 or ((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 6291963) != 0):
                self.state = 345
                self.expression()


            self.state = 348
            self.match(CSharpLexerParser.SEMI)
            self.state = 350
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==1 or ((((_la - 99)) & ~0x3f) == 0 and ((1 << (_la - 99)) & 6291963) != 0):
                self.state = 349
                self.forIterator()


            self.state = 352
            self.match(CSharpLexerParser.RPAREN)
            self.state = 353
            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 ForInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def localVariableDeclaration(self):
            return self.getTypedRuleContext(CSharpLexerParser.LocalVariableDeclarationContext,0)


        def expressionList(self):
            return self.getTypedRuleContext(CSharpLexerParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_forInitializer

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

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

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




    def forInitializer(self):

        localctx = CSharpLexerParser.ForInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_forInitializer)
        try:
            self.state = 357
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,26,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 355
                self.localVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 356
                self.expressionList()
                pass


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


    class ForIteratorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expressionList(self):
            return self.getTypedRuleContext(CSharpLexerParser.ExpressionListContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_forIterator

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

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

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




    def forIterator(self):

        localctx = CSharpLexerParser.ForIteratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_forIterator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 359
            self.expressionList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForeachStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOREACH(self):
            return self.getToken(CSharpLexerParser.FOREACH, 0)

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

        def type_identifier(self):
            return self.getTypedRuleContext(CSharpLexerParser.Type_identifierContext,0)


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

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


        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

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


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_foreachStatement

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

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

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




    def foreachStatement(self):

        localctx = CSharpLexerParser.ForeachStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_foreachStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.match(CSharpLexerParser.FOREACH)
            self.state = 362
            self.match(CSharpLexerParser.LPAREN)
            self.state = 363
            self.type_identifier()
            self.state = 364
            self.match(CSharpLexerParser.IN)
            self.state = 365
            self.expression()
            self.state = 366
            self.match(CSharpLexerParser.RPAREN)
            self.state = 367
            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 BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

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


        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlock" ):
                return visitor.visitBlock(self)
            else:
                return visitor.visitChildren(self)




    def block(self):

        localctx = CSharpLexerParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 369
            self.match(CSharpLexerParser.LBRACE)
            self.state = 373
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 3096293463293954) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & 1511861747713) != 0):
                self.state = 370
                self.statement()
                self.state = 375
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 376
            self.match(CSharpLexerParser.RBRACE)
        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 controlStructure(self):
            return self.getTypedRuleContext(CSharpLexerParser.ControlStructureContext,0)


        def expressionStatement(self):
            return self.getTypedRuleContext(CSharpLexerParser.ExpressionStatementContext,0)


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


        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStatement" ):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)




    def statement(self):

        localctx = CSharpLexerParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_statement)
        try:
            self.state = 381
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [36, 48, 49, 51, 83, 98]:
                self.enterOuterAlt(localctx, 1)
                self.state = 378
                self.controlStructure()
                pass
            elif token in [1, 99, 100, 102, 103, 104, 105, 106, 107, 120, 121]:
                self.enterOuterAlt(localctx, 2)
                self.state = 379
                self.expressionStatement()
                pass
            elif token in [123]:
                self.enterOuterAlt(localctx, 3)
                self.state = 380
                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 ExpressionStatementContext(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(CSharpLexerParser.ExpressionContext,0)


        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_expressionStatement

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

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

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




    def expressionStatement(self):

        localctx = CSharpLexerParser.ExpressionStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_expressionStatement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 383
            self.expression()
            self.state = 384
            self.match(CSharpLexerParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionListContext(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(CSharpLexerParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.ExpressionContext,i)


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_expressionList

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

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

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




    def expressionList(self):

        localctx = CSharpLexerParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_expressionList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 386
            self.expression()
            self.state = 391
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==126:
                self.state = 387
                self.match(CSharpLexerParser.COMMA)
                self.state = 388
                self.expression()
                self.state = 393
                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 CompilationUnitContext(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(CSharpLexerParser.EOF, 0)

        def classDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.ClassDeclarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.ClassDeclarationContext,i)


        def methodDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.MethodDeclarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.MethodDeclarationContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_compilationUnit

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

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

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




    def compilationUnit(self):

        localctx = CSharpLexerParser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_compilationUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 398
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377905002373775360) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 10267673661) != 0):
                self.state = 396
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
                if la_ == 1:
                    self.state = 394
                    self.classDeclaration()
                    pass

                elif la_ == 2:
                    self.state = 395
                    self.methodDeclaration()
                    pass


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

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


    class ClassDeclarationContext(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(CSharpLexerParser.CLASS, 0)

        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def classBody(self):
            return self.getTypedRuleContext(CSharpLexerParser.ClassBodyContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpLexerParser.AttributesContext,0)


        def modifiers(self):
            return self.getTypedRuleContext(CSharpLexerParser.ModifiersContext,0)


        def typeParameters(self):
            return self.getTypedRuleContext(CSharpLexerParser.TypeParametersContext,0)


        def classBase(self):
            return self.getTypedRuleContext(CSharpLexerParser.ClassBaseContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_classDeclaration

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

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

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




    def classDeclaration(self):

        localctx = CSharpLexerParser.ClassDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_classDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 404
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 403
                self.attributes()


            self.state = 407
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377905001299968000) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 603997245) != 0):
                self.state = 406
                self.modifiers()


            self.state = 409
            self.match(CSharpLexerParser.CLASS)
            self.state = 410
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 412
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==115:
                self.state = 411
                self.typeParameters()


            self.state = 415
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==5:
                self.state = 414
                self.classBase()


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


    class ClassBaseContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_classBase

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

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

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




    def classBase(self):

        localctx = CSharpLexerParser.ClassBaseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_classBase)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 419
            self.match(CSharpLexerParser.T__4)
            self.state = 420
            self.type_()
            self.state = 425
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==126:
                self.state = 421
                self.match(CSharpLexerParser.COMMA)
                self.state = 422
                self.type_()
                self.state = 427
                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 ClassBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def classMemberDeclaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.ClassMemberDeclarationContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.ClassMemberDeclarationContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_classBody

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

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

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




    def classBody(self):

        localctx = CSharpLexerParser.ClassBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_classBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 428
            self.match(CSharpLexerParser.LBRACE)
            self.state = 432
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377905001300033536) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 10267673661) != 0):
                self.state = 429
                self.classMemberDeclaration()
                self.state = 434
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 435
            self.match(CSharpLexerParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ClassMemberDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def methodDeclaration(self):
            return self.getTypedRuleContext(CSharpLexerParser.MethodDeclarationContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_classMemberDeclaration

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

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

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




    def classMemberDeclaration(self):

        localctx = CSharpLexerParser.ClassMemberDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_classMemberDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 437
            self.methodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MethodDeclarationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def returnType(self):
            return self.getTypedRuleContext(CSharpLexerParser.ReturnTypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def LPAREN(self):
            return self.getToken(CSharpLexerParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(CSharpLexerParser.RPAREN, 0)

        def methodBody(self):
            return self.getTypedRuleContext(CSharpLexerParser.MethodBodyContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpLexerParser.AttributesContext,0)


        def modifiers(self):
            return self.getTypedRuleContext(CSharpLexerParser.ModifiersContext,0)


        def typeParameters(self):
            return self.getTypedRuleContext(CSharpLexerParser.TypeParametersContext,0)


        def formalParameterList(self):
            return self.getTypedRuleContext(CSharpLexerParser.FormalParameterListContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_methodDeclaration

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

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

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




    def methodDeclaration(self):

        localctx = CSharpLexerParser.MethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_methodDeclaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 440
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 439
                self.attributes()


            self.state = 443
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2377905001299968000) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 603997245) != 0):
                self.state = 442
                self.modifiers()


            self.state = 445
            self.returnType()
            self.state = 446
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 448
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==115:
                self.state = 447
                self.typeParameters()


            self.state = 450
            self.match(CSharpLexerParser.LPAREN)
            self.state = 452
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16 or _la==53 or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & 17180393605) != 0):
                self.state = 451
                self.formalParameterList()


            self.state = 454
            self.match(CSharpLexerParser.RPAREN)
            self.state = 455
            self.methodBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ReturnTypeContext(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(CSharpLexerParser.TypeContext,0)


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_returnType

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

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

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




    def returnType(self):

        localctx = CSharpLexerParser.ReturnTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_returnType)
        try:
            self.state = 459
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [99]:
                self.enterOuterAlt(localctx, 1)
                self.state = 457
                self.type_()
                pass
            elif token in [96]:
                self.enterOuterAlt(localctx, 2)
                self.state = 458
                self.match(CSharpLexerParser.VOID)
                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 FormalParameterListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def fixedParameters(self):
            return self.getTypedRuleContext(CSharpLexerParser.FixedParametersContext,0)


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

        def parameterArray(self):
            return self.getTypedRuleContext(CSharpLexerParser.ParameterArrayContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_formalParameterList

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

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

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




    def formalParameterList(self):

        localctx = CSharpLexerParser.FormalParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_formalParameterList)
        self._la = 0 # Token type
        try:
            self.state = 467
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 461
                self.fixedParameters()
                self.state = 464
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==126:
                    self.state = 462
                    self.match(CSharpLexerParser.COMMA)
                    self.state = 463
                    self.parameterArray()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 466
                self.parameterArray()
                pass


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


    class FixedParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def fixedParameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.FixedParameterContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.FixedParameterContext,i)


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_fixedParameters

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

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

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




    def fixedParameters(self):

        localctx = CSharpLexerParser.FixedParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_fixedParameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self.fixedParameter()
            self.state = 474
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 470
                    self.match(CSharpLexerParser.COMMA)
                    self.state = 471
                    self.fixedParameter() 
                self.state = 476
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,45,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 FixedParameterContext(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(CSharpLexerParser.TypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpLexerParser.AttributesContext,0)


        def parameterModifier(self):
            return self.getTypedRuleContext(CSharpLexerParser.ParameterModifierContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_fixedParameter

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

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

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




    def fixedParameter(self):

        localctx = CSharpLexerParser.FixedParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_fixedParameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 478
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 477
                self.attributes()


            self.state = 481
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 53)) & ~0x3f) == 0 and ((1 << (_la - 53)) & 2148012033) != 0):
                self.state = 480
                self.parameterModifier()


            self.state = 483
            self.type_()
            self.state = 484
            self.match(CSharpLexerParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParameterModifierContext(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(CSharpLexerParser.REF, 0)

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

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

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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_parameterModifier

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

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

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




    def parameterModifier(self):

        localctx = CSharpLexerParser.ParameterModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_parameterModifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486
            _la = self._input.LA(1)
            if not(((((_la - 53)) & ~0x3f) == 0 and ((1 << (_la - 53)) & 2148012033) != 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 ParameterArrayContext(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(CSharpLexerParser.PARAMS, 0)

        def type_(self):
            return self.getTypedRuleContext(CSharpLexerParser.TypeContext,0)


        def IDENTIFIER(self):
            return self.getToken(CSharpLexerParser.IDENTIFIER, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpLexerParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_parameterArray

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

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

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




    def parameterArray(self):

        localctx = CSharpLexerParser.ParameterArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_parameterArray)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 489
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==16:
                self.state = 488
                self.attributes()


            self.state = 491
            self.match(CSharpLexerParser.PARAMS)
            self.state = 492
            self.type_()
            self.state = 493
            self.match(CSharpLexerParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MethodBodyContext(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(CSharpLexerParser.BlockContext,0)


        def SEMI(self):
            return self.getToken(CSharpLexerParser.SEMI, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_methodBody

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

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

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




    def methodBody(self):

        localctx = CSharpLexerParser.MethodBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_methodBody)
        try:
            self.state = 497
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [123]:
                self.enterOuterAlt(localctx, 1)
                self.state = 495
                self.block()
                pass
            elif token in [125]:
                self.enterOuterAlt(localctx, 2)
                self.state = 496
                self.match(CSharpLexerParser.SEMI)
                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 TypeContext(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(CSharpLexerParser.IDENTIFIER, 0)

        def LESSTHAN(self):
            return self.getToken(CSharpLexerParser.LESSTHAN, 0)

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


        def BIGGERTHAN(self):
            return self.getToken(CSharpLexerParser.BIGGERTHAN, 0)

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

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitType" ):
                return visitor.visitType(self)
            else:
                return visitor.visitChildren(self)




    def type_(self):

        localctx = CSharpLexerParser.TypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 499
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 511
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==115:
                self.state = 500
                self.match(CSharpLexerParser.LESSTHAN)
                self.state = 501
                self.type_()
                self.state = 506
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==126:
                    self.state = 502
                    self.match(CSharpLexerParser.COMMA)
                    self.state = 503
                    self.type_()
                    self.state = 508
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 509
                self.match(CSharpLexerParser.BIGGERTHAN)


            self.state = 517
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==16:
                self.state = 513
                self.match(CSharpLexerParser.T__15)
                self.state = 514
                self.match(CSharpLexerParser.T__16)
                self.state = 519
                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 AttributesContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def attributeSection(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.AttributeSectionContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.AttributeSectionContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttributes" ):
                return visitor.visitAttributes(self)
            else:
                return visitor.visitChildren(self)




    def attributes(self):

        localctx = CSharpLexerParser.AttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 521 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 520
                self.attributeSection()
                self.state = 523 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==16):
                    break

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


    class AttributeSectionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def attributeList(self):
            return self.getTypedRuleContext(CSharpLexerParser.AttributeListContext,0)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_attributeSection

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

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

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




    def attributeSection(self):

        localctx = CSharpLexerParser.AttributeSectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_attributeSection)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 525
            self.match(CSharpLexerParser.T__15)
            self.state = 526
            self.attributeList()
            self.state = 527
            self.match(CSharpLexerParser.T__16)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeListContext(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(CSharpLexerParser.AttributeContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.AttributeContext,i)


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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_attributeList

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

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

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




    def attributeList(self):

        localctx = CSharpLexerParser.AttributeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_attributeList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 529
            self.attribute()
            self.state = 534
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==126:
                self.state = 530
                self.match(CSharpLexerParser.COMMA)
                self.state = 531
                self.attribute()
                self.state = 536
                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 AttributeContext(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(CSharpLexerParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAttribute" ):
                return visitor.visitAttribute(self)
            else:
                return visitor.visitChildren(self)




    def attribute(self):

        localctx = CSharpLexerParser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_attribute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 537
            self.match(CSharpLexerParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModifiersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def modifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpLexerParser.ModifierContext)
            else:
                return self.getTypedRuleContext(CSharpLexerParser.ModifierContext,i)


        def getRuleIndex(self):
            return CSharpLexerParser.RULE_modifiers

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

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

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




    def modifiers(self):

        localctx = CSharpLexerParser.ModifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_modifiers)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 540 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 539
                self.modifier()
                self.state = 542 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 2377905001299968000) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 603997245) != 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 ModifierContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PUBLIC(self):
            return self.getToken(CSharpLexerParser.PUBLIC, 0)

        def PRIVATE(self):
            return self.getToken(CSharpLexerParser.PRIVATE, 0)

        def PROTECTED(self):
            return self.getToken(CSharpLexerParser.PROTECTED, 0)

        def INTERNAL(self):
            return self.getToken(CSharpLexerParser.INTERNAL, 0)

        def STATIC(self):
            return self.getToken(CSharpLexerParser.STATIC, 0)

        def ABSTRACT(self):
            return self.getToken(CSharpLexerParser.ABSTRACT, 0)

        def VIRTUAL(self):
            return self.getToken(CSharpLexerParser.VIRTUAL, 0)

        def OVERRIDE(self):
            return self.getToken(CSharpLexerParser.OVERRIDE, 0)

        def SEALED(self):
            return self.getToken(CSharpLexerParser.SEALED, 0)

        def READONLY(self):
            return self.getToken(CSharpLexerParser.READONLY, 0)

        def UNSAFE(self):
            return self.getToken(CSharpLexerParser.UNSAFE, 0)

        def EXTERN(self):
            return self.getToken(CSharpLexerParser.EXTERN, 0)

        def NEW(self):
            return self.getToken(CSharpLexerParser.NEW, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_modifier

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

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

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




    def modifier(self):

        localctx = CSharpLexerParser.ModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_modifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2377905001299968000) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & 603997245) != 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 TypeParametersContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LESSTHAN(self):
            return self.getToken(CSharpLexerParser.LESSTHAN, 0)

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

        def BIGGERTHAN(self):
            return self.getToken(CSharpLexerParser.BIGGERTHAN, 0)

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

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_typeParameters

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

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

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




    def typeParameters(self):

        localctx = CSharpLexerParser.TypeParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_typeParameters)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 546
            self.match(CSharpLexerParser.LESSTHAN)
            self.state = 547
            self.match(CSharpLexerParser.IDENTIFIER)
            self.state = 552
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==126:
                self.state = 548
                self.match(CSharpLexerParser.COMMA)
                self.state = 549
                self.match(CSharpLexerParser.IDENTIFIER)
                self.state = 554
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 555
            self.match(CSharpLexerParser.BIGGERTHAN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Null_literalContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NULL_LITERAL(self):
            return self.getToken(CSharpLexerParser.NULL_LITERAL, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.RULE_null_literal

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

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

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




    def null_literal(self):

        localctx = CSharpLexerParser.Null_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_null_literal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 557
            self.match(CSharpLexerParser.NULL_LITERAL)
        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 BOOL_LITERAL(self):
            return self.getToken(CSharpLexerParser.BOOL_LITERAL, 0)

        def getRuleIndex(self):
            return CSharpLexerParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBoolean_literal" ):
                return visitor.visitBoolean_literal(self)
            else:
                return visitor.visitChildren(self)




    def boolean_literal(self):

        localctx = CSharpLexerParser.Boolean_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_boolean_literal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 559
            self.match(CSharpLexerParser.BOOL_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx