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


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00c2")
        buf.write("\u094c\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4")
        buf.write("q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4")
        buf.write("z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080")
        buf.write("\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084")
        buf.write("\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087")
        buf.write("\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b")
        buf.write("\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e")
        buf.write("\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092")
        buf.write("\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095")
        buf.write("\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099")
        buf.write("\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c")
        buf.write("\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0")
        buf.write("\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3")
        buf.write("\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7")
        buf.write("\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa")
        buf.write("\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\4\u00ae")
        buf.write("\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1")
        buf.write("\4\u00b2\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5")
        buf.write("\t\u00b5\4\u00b6\t\u00b6\4\u00b7\t\u00b7\4\u00b8\t\u00b8")
        buf.write("\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb\t\u00bb\4\u00bc")
        buf.write("\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf")
        buf.write("\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3")
        buf.write("\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6")
        buf.write("\4\u00c7\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca")
        buf.write("\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\3\2\5\2\u019a")
        buf.write("\n\2\3\2\5\2\u019d\n\2\3\2\5\2\u01a0\n\2\3\2\7\2\u01a3")
        buf.write("\n\2\f\2\16\2\u01a6\13\2\3\2\5\2\u01a9\n\2\3\2\3\2\3\3")
        buf.write("\3\3\5\3\u01af\n\3\3\3\5\3\u01b2\n\3\3\3\3\3\3\3\5\3\u01b7")
        buf.write("\n\3\7\3\u01b9\n\3\f\3\16\3\u01bc\13\3\3\4\3\4\3\4\3\4")
        buf.write("\7\4\u01c2\n\4\f\4\16\4\u01c5\13\4\3\5\3\5\3\5\3\5\5\5")
        buf.write("\u01cb\n\5\3\6\3\6\5\6\u01cf\n\6\3\7\3\7\3\7\5\7\u01d4")
        buf.write("\n\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u01de\n\n\3\13")
        buf.write("\3\13\3\13\3\13\7\13\u01e4\n\13\f\13\16\13\u01e7\13\13")
        buf.write("\3\13\3\13\3\f\3\f\3\f\7\f\u01ee\n\f\f\f\16\f\u01f1\13")
        buf.write("\f\3\r\3\r\3\r\5\r\u01f6\n\r\3\r\5\r\u01f9\n\r\3\r\3\r")
        buf.write("\5\r\u01fd\n\r\3\r\3\r\3\16\3\16\5\16\u0203\n\16\3\17")
        buf.write("\3\17\3\17\5\17\u0208\n\17\3\20\3\20\3\20\3\20\3\21\3")
        buf.write("\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21")
        buf.write("\u0219\n\21\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u0221\n")
        buf.write("\22\3\23\3\23\3\23\5\23\u0226\n\23\3\24\3\24\3\24\7\24")
        buf.write("\u022b\n\24\f\24\16\24\u022e\13\24\3\25\3\25\3\25\7\25")
        buf.write("\u0233\n\25\f\25\16\25\u0236\13\25\3\26\3\26\3\26\7\26")
        buf.write("\u023b\n\26\f\26\16\26\u023e\13\26\3\27\3\27\3\27\7\27")
        buf.write("\u0243\n\27\f\27\16\27\u0246\13\27\3\30\3\30\3\30\7\30")
        buf.write("\u024b\n\30\f\30\16\30\u024e\13\30\3\31\3\31\3\31\7\31")
        buf.write("\u0253\n\31\f\31\16\31\u0256\13\31\3\32\3\32\3\32\3\32")
        buf.write("\3\32\3\32\3\32\7\32\u025f\n\32\f\32\16\32\u0262\13\32")
        buf.write("\3\33\3\33\3\33\5\33\u0267\n\33\3\33\7\33\u026a\n\33\f")
        buf.write("\33\16\33\u026d\13\33\3\34\3\34\3\34\7\34\u0272\n\34\f")
        buf.write("\34\16\34\u0275\13\34\3\35\3\35\3\35\7\35\u027a\n\35\f")
        buf.write("\35\16\35\u027d\13\35\3\36\3\36\3\36\3\36\3\36\3\36\3")
        buf.write("\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36")
        buf.write("\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u0297\n\36\3")
        buf.write("\37\3\37\7\37\u029b\n\37\f\37\16\37\u029e\13\37\3\37\3")
        buf.write("\37\3\37\3\37\3\37\3\37\5\37\u02a6\n\37\3\37\7\37\u02a9")
        buf.write("\n\37\f\37\16\37\u02ac\13\37\7\37\u02ae\n\37\f\37\16\37")
        buf.write("\u02b1\13\37\3 \3 \3 \5 \u02b6\n \3 \3 \3 \3 \3 \3 \3")
        buf.write(" \3 \3 \3 \3 \3 \5 \u02c4\n \3 \3 \3 \3 \5 \u02ca\n \3")
        buf.write(" \3 \3 \3 \3 \3 \3 \3 \7 \u02d4\n \f \16 \u02d7\13 \3")
        buf.write(" \5 \u02da\n \3 \6 \u02dd\n \r \16 \u02de\3 \3 \5 \u02e3")
        buf.write("\n \3 \3 \3 \3 \5 \u02e9\n \3 \3 \3 \3 \3 \5 \u02f0\n")
        buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \3 \5")
        buf.write(" \u0303\n \3 \3 \3 \5 \u0308\n \3 \5 \u030b\n \3 \3 \3")
        buf.write(" \3 \3 \3 \3 \3 \3 \3 \3 \7 \u0318\n \f \16 \u031b\13")
        buf.write(" \3 \3 \3 \5 \u0320\n \3!\5!\u0323\n!\3!\3!\3!\5!\u0328")
        buf.write("\n!\3\"\5\"\u032b\n\"\3\"\3\"\3\"\3\"\7\"\u0331\n\"\f")
        buf.write("\"\16\"\u0334\13\"\3\"\3\"\3#\3#\3#\5#\u033b\n#\3#\3#")
        buf.write("\3$\3$\3%\3%\3%\7%\u0344\n%\f%\16%\u0347\13%\3&\3&\5&")
        buf.write("\u034b\n&\3\'\3\'\3\'\5\'\u0350\n\'\5\'\u0352\n\'\3\'")
        buf.write("\3\'\3(\3(\3(\7(\u0359\n(\f(\16(\u035c\13(\3)\3)\3)\3")
        buf.write(")\3)\5)\u0363\n)\3)\3)\3)\3*\3*\5*\u036a\n*\3+\3+\3+\3")
        buf.write("+\7+\u0370\n+\f+\16+\u0373\13+\3+\5+\u0376\n+\3+\3+\3")
        buf.write(",\3,\3,\3,\3,\5,\u037f\n,\3-\3-\3-\5-\u0384\n-\5-\u0386")
        buf.write("\n-\3-\3-\3.\3.\3.\7.\u038d\n.\f.\16.\u0390\13.\3/\3/")
        buf.write("\3/\3/\3/\5/\u0397\n/\3\60\3\60\5\60\u039b\n\60\3\60\3")
        buf.write("\60\3\60\5\60\u03a0\n\60\5\60\u03a2\n\60\3\60\3\60\3\60")
        buf.write("\5\60\u03a7\n\60\7\60\u03a9\n\60\f\60\16\60\u03ac\13\60")
        buf.write("\3\61\3\61\7\61\u03b0\n\61\f\61\16\61\u03b3\13\61\3\61")
        buf.write("\3\61\3\62\3\62\3\62\7\62\u03ba\n\62\f\62\16\62\u03bd")
        buf.write("\13\62\3\62\5\62\u03c0\n\62\3\63\5\63\u03c3\n\63\3\63")
        buf.write("\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64")
        buf.write("\3\64\3\64\3\64\5\64\u03d4\n\64\3\65\3\65\3\65\7\65\u03d9")
        buf.write("\n\65\f\65\16\65\u03dc\13\65\3\66\5\66\u03df\n\66\3\66")
        buf.write("\3\66\3\66\3\67\3\67\3\67\7\67\u03e7\n\67\f\67\16\67\u03ea")
        buf.write("\13\67\38\38\58\u03ee\n8\39\39\39\3:\3:\5:\u03f5\n:\3")
        buf.write(":\3:\3:\3:\3;\7;\u03fc\n;\f;\16;\u03ff\13;\3;\3;\5;\u0403")
        buf.write("\n;\3<\3<\3<\3<\3<\5<\u040a\n<\3=\3=\3=\3=\3=\3>\3>\3")
        buf.write(">\3?\3?\5?\u0416\n?\3?\3?\3?\3?\3?\3?\3?\3?\3?\5?\u0421")
        buf.write("\n?\3@\3@\3@\3@\7@\u0427\n@\f@\16@\u042a\13@\3A\3A\5A")
        buf.write("\u042e\nA\3B\3B\3B\3B\3B\3B\3B\5B\u0437\nB\3C\3C\3C\3")
        buf.write("C\3D\3D\3D\5D\u0440\nD\3D\3D\3D\5D\u0445\nD\3E\3E\3E\3")
        buf.write("E\3F\3F\5F\u044d\nF\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\5")
        buf.write("G\u045a\nG\3G\3G\3G\3G\3G\3G\7G\u0462\nG\fG\16G\u0465")
        buf.write("\13G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3")
        buf.write("G\3G\3G\5G\u047a\nG\3G\3G\5G\u047e\nG\3G\3G\5G\u0482\n")
        buf.write("G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3")
        buf.write("G\3G\3G\5G\u0498\nG\3G\3G\3G\5G\u049d\nG\3G\3G\3G\5G\u04a2")
        buf.write("\nG\3G\3G\3G\3G\3G\5G\u04a9\nG\3G\5G\u04ac\nG\3G\3G\3")
        buf.write("G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\5")
        buf.write("G\u04c2\nG\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\5G\u04ce\nG\3")
        buf.write("H\3H\5H\u04d2\nH\3H\3H\3I\3I\3I\3I\7I\u04da\nI\fI\16I")
        buf.write("\u04dd\13I\3J\3J\5J\u04e1\nJ\3K\3K\3K\5K\u04e6\nK\3L\3")
        buf.write("L\3L\5L\u04eb\nL\3M\3M\3M\3M\3N\3N\5N\u04f3\nN\3O\6O\u04f6")
        buf.write("\nO\rO\16O\u04f7\3O\3O\3P\3P\3P\3P\3P\3P\5P\u0502\nP\3")
        buf.write("Q\6Q\u0505\nQ\rQ\16Q\u0506\3R\3R\3R\3R\7R\u050d\nR\fR")
        buf.write("\16R\u0510\13R\5R\u0512\nR\3S\3S\3S\7S\u0517\nS\fS\16")
        buf.write("S\u051a\13S\3T\3T\7T\u051e\nT\fT\16T\u0521\13T\3T\5T\u0524")
        buf.write("\nT\3T\5T\u0527\nT\3U\3U\3U\3U\5U\u052d\nU\3U\3U\5U\u0531")
        buf.write("\nU\3U\3U\3V\3V\5V\u0537\nV\3V\3V\3W\3W\3W\3W\3W\3X\3")
        buf.write("X\3X\3Y\3Y\5Y\u0545\nY\3Z\3Z\3Z\3Z\5Z\u054b\nZ\3[\3[\3")
        buf.write("[\7[\u0550\n[\f[\16[\u0553\13[\3\\\3\\\5\\\u0557\n\\\3")
        buf.write("\\\5\\\u055a\n\\\3\\\5\\\u055d\n\\\3\\\3\\\3]\6]\u0562")
        buf.write("\n]\r]\16]\u0563\3^\3^\3^\3^\3^\3_\6_\u056c\n_\r_\16_")
        buf.write("\u056d\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\5")
        buf.write("`\u057f\n`\3a\6a\u0582\na\ra\16a\u0583\3b\3b\3b\5b\u0589")
        buf.write("\nb\3c\5c\u058c\nc\3c\5c\u058f\nc\3c\3c\3c\3c\3c\5c\u0596")
        buf.write("\nc\3d\3d\3d\3d\5d\u059c\nd\3e\3e\3e\3e\7e\u05a2\ne\f")
        buf.write("e\16e\u05a5\13e\3e\3e\3f\5f\u05aa\nf\3f\3f\3g\3g\3g\3")
        buf.write("g\7g\u05b2\ng\fg\16g\u05b5\13g\3h\3h\3h\7h\u05ba\nh\f")
        buf.write("h\16h\u05bd\13h\3i\6i\u05c0\ni\ri\16i\u05c1\3j\3j\3j\3")
        buf.write("j\3j\3k\3k\3k\3k\5k\u05cd\nk\3k\3k\5k\u05d1\nk\5k\u05d3")
        buf.write("\nk\3l\3l\3l\5l\u05d8\nl\3m\3m\3m\7m\u05dd\nm\fm\16m\u05e0")
        buf.write("\13m\3n\3n\3n\3n\3o\3o\5o\u05e8\no\3o\3o\3p\6p\u05ed\n")
        buf.write("p\rp\16p\u05ee\3q\3q\5q\u05f3\nq\3q\5q\u05f6\nq\3q\3q")
        buf.write("\5q\u05fa\nq\5q\u05fc\nq\3r\6r\u05ff\nr\rr\16r\u0600\3")
        buf.write("s\3s\3t\3t\3t\3t\3t\3t\3t\3t\3t\5t\u060e\nt\3t\3t\3t\3")
        buf.write("t\3t\3t\3t\3t\5t\u0618\nt\3u\3u\3u\3u\3u\3u\3u\3u\3u\3")
        buf.write("u\5u\u0624\nu\3v\3v\3v\7v\u0629\nv\fv\16v\u062c\13v\3")
        buf.write("w\3w\3w\3w\3x\3x\3x\7x\u0635\nx\fx\16x\u0638\13x\3y\3")
        buf.write("y\3y\5y\u063d\ny\3z\3z\5z\u0641\nz\3{\3{\5{\u0645\n{\3")
        buf.write("|\3|\3}\3}\5}\u064b\n}\3~\3~\3~\3~\5~\u0651\n~\5~\u0653")
        buf.write("\n~\3\177\3\177\3\177\7\177\u0658\n\177\f\177\16\177\u065b")
        buf.write("\13\177\3\u0080\5\u0080\u065e\n\u0080\3\u0080\5\u0080")
        buf.write("\u0661\n\u0080\3\u0080\3\u0080\5\u0080\u0665\n\u0080\3")
        buf.write("\u0081\3\u0081\3\u0082\5\u0082\u066a\n\u0082\3\u0082\3")
        buf.write("\u0082\3\u0082\3\u0082\3\u0083\5\u0083\u0671\n\u0083\3")
        buf.write("\u0083\5\u0083\u0674\n\u0083\3\u0083\3\u0083\3\u0083\5")
        buf.write("\u0083\u0679\n\u0083\3\u0083\3\u0083\3\u0083\5\u0083\u067e")
        buf.write("\n\u0083\5\u0083\u0680\n\u0083\3\u0084\5\u0084\u0683\n")
        buf.write("\u0084\3\u0084\5\u0084\u0686\n\u0084\3\u0084\3\u0084\3")
        buf.write("\u0084\3\u0085\5\u0085\u068c\n\u0085\3\u0085\5\u0085\u068f")
        buf.write("\n\u0085\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086")
        buf.write("\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u069b\n\u0086")
        buf.write("\3\u0087\3\u0087\5\u0087\u069f\n\u0087\3\u0088\5\u0088")
        buf.write("\u06a2\n\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3\u0088")
        buf.write("\3\u0088\3\u0088\3\u0088\5\u0088\u06ac\n\u0088\3\u0089")
        buf.write("\5\u0089\u06af\n\u0089\3\u0089\3\u0089\3\u0089\3\u008a")
        buf.write("\5\u008a\u06b5\n\u008a\3\u008a\3\u008a\3\u008a\3\u008b")
        buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
        buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
        buf.write("\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b")
        buf.write("\5\u008b\u06d0\n\u008b\3\u008c\3\u008c\3\u008c\3\u008c")
        buf.write("\3\u008c\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\3\u008d")
        buf.write("\5\u008d\u06dd\n\u008d\3\u008d\3\u008d\3\u008e\3\u008e")
        buf.write("\5\u008e\u06e3\n\u008e\3\u008f\3\u008f\3\u008f\3\u0090")
        buf.write("\3\u0090\7\u0090\u06ea\n\u0090\f\u0090\16\u0090\u06ed")
        buf.write("\13\u0090\3\u0090\3\u0090\3\u0091\5\u0091\u06f2\n\u0091")
        buf.write("\3\u0091\5\u0091\u06f5\n\u0091\3\u0091\3\u0091\3\u0091")
        buf.write("\3\u0091\6\u0091\u06fb\n\u0091\r\u0091\16\u0091\u06fc")
        buf.write("\3\u0091\3\u0091\5\u0091\u0701\n\u0091\3\u0092\3\u0092")
        buf.write("\7\u0092\u0705\n\u0092\f\u0092\16\u0092\u0708\13\u0092")
        buf.write("\3\u0092\6\u0092\u070b\n\u0092\r\u0092\16\u0092\u070c")
        buf.write("\3\u0093\3\u0093\7\u0093\u0711\n\u0093\f\u0093\16\u0093")
        buf.write("\u0714\13\u0093\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094")
        buf.write("\3\u0094\7\u0094\u071c\n\u0094\f\u0094\16\u0094\u071f")
        buf.write("\13\u0094\3\u0094\5\u0094\u0722\n\u0094\5\u0094\u0724")
        buf.write("\n\u0094\3\u0094\3\u0094\3\u0095\3\u0095\3\u0095\3\u0095")
        buf.write("\7\u0095\u072c\n\u0095\f\u0095\16\u0095\u072f\13\u0095")
        buf.write("\3\u0095\3\u0095\3\u0096\5\u0096\u0734\n\u0096\3\u0096")
        buf.write("\5\u0096\u0737\n\u0096\3\u0096\3\u0096\3\u0097\3\u0097")
        buf.write("\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\7\u0099\u0742")
        buf.write("\n\u0099\f\u0099\16\u0099\u0745\13\u0099\3\u0099\3\u0099")
        buf.write("\3\u009a\5\u009a\u074a\n\u009a\3\u009a\5\u009a\u074d\n")
        buf.write("\u009a\3\u009a\5\u009a\u0750\n\u009a\3\u009a\3\u009a\3")
        buf.write("\u009a\5\u009a\u0755\n\u009a\3\u009a\3\u009a\5\u009a\u0759")
        buf.write("\n\u009a\3\u009a\3\u009a\5\u009a\u075d\n\u009a\3\u009a")
        buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
        buf.write("\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
        buf.write("\5\u009a\u076e\n\u009a\3\u009a\5\u009a\u0771\n\u009a\3")
        buf.write("\u009a\3\u009a\3\u009a\5\u009a\u0776\n\u009a\3\u009a\3")
        buf.write("\u009a\5\u009a\u077a\n\u009a\3\u009a\3\u009a\5\u009a\u077e")
        buf.write("\n\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a")
        buf.write("\3\u009a\5\u009a\u0787\n\u009a\3\u009b\5\u009b\u078a\n")
        buf.write("\u009b\3\u009b\3\u009b\3\u009b\5\u009b\u078f\n\u009b\3")
        buf.write("\u009b\3\u009b\5\u009b\u0793\n\u009b\3\u009b\3\u009b\3")
        buf.write("\u009b\5\u009b\u0798\n\u009b\3\u009b\3\u009b\5\u009b\u079c")
        buf.write("\n\u009b\5\u009b\u079e\n\u009b\3\u009c\3\u009c\3\u009c")
        buf.write("\3\u009d\3\u009d\3\u009d\3\u009d\7\u009d\u07a7\n\u009d")
        buf.write("\f\u009d\16\u009d\u07aa\13\u009d\3\u009d\5\u009d\u07ad")
        buf.write("\n\u009d\5\u009d\u07af\n\u009d\3\u009d\3\u009d\3\u009e")
        buf.write("\5\u009e\u07b4\n\u009e\3\u009e\3\u009e\3\u009e\5\u009e")
        buf.write("\u07b9\n\u009e\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f")
        buf.write("\5\u009f\u07c0\n\u009f\3\u009f\3\u009f\3\u00a0\3\u00a0")
        buf.write("\5\u00a0\u07c6\n\u00a0\3\u00a1\6\u00a1\u07c9\n\u00a1\r")
        buf.write("\u00a1\16\u00a1\u07ca\3\u00a2\3\u00a2\3\u00a2\3\u00a2")
        buf.write("\5\u00a2\u07d1\n\u00a2\3\u00a2\3\u00a2\5\u00a2\u07d5\n")
        buf.write("\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\5\u00a3\u07db\n")
        buf.write("\u00a3\3\u00a4\3\u00a4\3\u00a4\7\u00a4\u07e0\n\u00a4\f")
        buf.write("\u00a4\16\u00a4\u07e3\13\u00a4\3\u00a5\3\u00a5\3\u00a5")
        buf.write("\3\u00a5\3\u00a5\7\u00a5\u07ea\n\u00a5\f\u00a5\16\u00a5")
        buf.write("\u07ed\13\u00a5\5\u00a5\u07ef\n\u00a5\3\u00a5\5\u00a5")
        buf.write("\u07f2\n\u00a5\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u07f7\n")
        buf.write("\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\5\u00a7\u07fd\n")
        buf.write("\u00a7\3\u00a7\3\u00a7\7\u00a7\u0801\n\u00a7\f\u00a7\16")
        buf.write("\u00a7\u0804\13\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7")
        buf.write("\5\u00a7\u080a\n\u00a7\3\u00a8\3\u00a8\3\u00a8\7\u00a8")
        buf.write("\u080f\n\u00a8\f\u00a8\16\u00a8\u0812\13\u00a8\3\u00a9")
        buf.write("\3\u00a9\3\u00a9\3\u00a9\3\u00aa\5\u00aa\u0819\n\u00aa")
        buf.write("\3\u00aa\3\u00aa\5\u00aa\u081d\n\u00aa\3\u00ab\3\u00ab")
        buf.write("\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac")
        buf.write("\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ae")
        buf.write("\3\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af\3\u00af\3\u00af")
        buf.write("\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b0")
        buf.write("\5\u00b0\u083d\n\u00b0\3\u00b1\3\u00b1\3\u00b2\3\u00b2")
        buf.write("\3\u00b2\3\u00b2\5\u00b2\u0845\n\u00b2\3\u00b3\3\u00b3")
        buf.write("\7\u00b3\u0849\n\u00b3\f\u00b3\16\u00b3\u084c\13\u00b3")
        buf.write("\3\u00b3\3\u00b3\3\u00b4\3\u00b4\7\u00b4\u0852\n\u00b4")
        buf.write("\f\u00b4\16\u00b4\u0855\13\u00b4\3\u00b4\3\u00b4\3\u00b5")
        buf.write("\3\u00b5\3\u00b5\3\u00b5\5\u00b5\u085d\n\u00b5\3\u00b6")
        buf.write("\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0863\n\u00b6\3\u00b7")
        buf.write("\3\u00b7\3\u00b7\7\u00b7\u0868\n\u00b7\f\u00b7\16\u00b7")
        buf.write("\u086b\13\u00b7\3\u00b7\3\u00b7\6\u00b7\u086f\n\u00b7")
        buf.write("\r\u00b7\16\u00b7\u0870\5\u00b7\u0873\n\u00b7\3\u00b8")
        buf.write("\3\u00b8\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u087a\n\u00b9")
        buf.write("\3\u00b9\5\u00b9\u087d\n\u00b9\3\u00b9\5\u00b9\u0880\n")
        buf.write("\u00b9\3\u00b9\3\u00b9\5\u00b9\u0884\n\u00b9\3\u00ba\3")
        buf.write("\u00ba\3\u00ba\5\u00ba\u0889\n\u00ba\3\u00ba\5\u00ba\u088c")
        buf.write("\n\u00ba\3\u00ba\5\u00ba\u088f\n\u00ba\3\u00ba\3\u00ba")
        buf.write("\5\u00ba\u0893\n\u00ba\3\u00bb\3\u00bb\3\u00bb\5\u00bb")
        buf.write("\u0898\n\u00bb\3\u00bb\5\u00bb\u089b\n\u00bb\3\u00bb\5")
        buf.write("\u00bb\u089e\n\u00bb\3\u00bb\3\u00bb\5\u00bb\u08a2\n\u00bb")
        buf.write("\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u08a7\n\u00bc\3\u00bc")
        buf.write("\3\u00bc\5\u00bc\u08ab\n\u00bc\3\u00bd\3\u00bd\3\u00bd")
        buf.write("\3\u00bd\5\u00bd\u08b1\n\u00bd\3\u00bd\3\u00bd\5\u00bd")
        buf.write("\u08b5\n\u00bd\3\u00bd\3\u00bd\5\u00bd\u08b9\n\u00bd\3")
        buf.write("\u00bd\3\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be")
        buf.write("\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\5\u00be\u08c7")
        buf.write("\n\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0")
        buf.write("\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u08d4")
        buf.write("\n\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u08da")
        buf.write("\n\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2")
        buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2")
        buf.write("\3\u00c2\3\u00c2\3\u00c2\3\u00c2\5\u00c2\u08ed\n\u00c2")
        buf.write("\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4")
        buf.write("\3\u00c4\3\u00c4\5\u00c4\u08f8\n\u00c4\3\u00c4\3\u00c4")
        buf.write("\5\u00c4\u08fc\n\u00c4\3\u00c4\3\u00c4\3\u00c5\3\u00c5")
        buf.write("\5\u00c5\u0902\n\u00c5\3\u00c5\3\u00c5\5\u00c5\u0906\n")
        buf.write("\u00c5\3\u00c5\3\u00c5\5\u00c5\u090a\n\u00c5\3\u00c5\3")
        buf.write("\u00c5\3\u00c5\3\u00c5\3\u00c5\5\u00c5\u0911\n\u00c5\3")
        buf.write("\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0918\n")
        buf.write("\u00c6\3\u00c6\5\u00c6\u091b\n\u00c6\3\u00c6\3\u00c6\7")
        buf.write("\u00c6\u091f\n\u00c6\f\u00c6\16\u00c6\u0922\13\u00c6\3")
        buf.write("\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\5\u00c7")
        buf.write("\u092a\n\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7")
        buf.write("\3\u00c7\5\u00c7\u0932\n\u00c7\3\u00c8\3\u00c8\3\u00c8")
        buf.write("\3\u00c8\5\u00c8\u0938\n\u00c8\3\u00c9\3\u00c9\5\u00c9")
        buf.write("\u093c\n\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\5\u00ca")
        buf.write("\u0942\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u0946\n\u00ca\3")
        buf.write("\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\2\2\u00cd\2\4\6")
        buf.write("\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66")
        buf.write("8:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084")
        buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096")
        buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8")
        buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba")
        buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc")
        buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de")
        buf.write("\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0")
        buf.write("\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102")
        buf.write("\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114")
        buf.write("\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126")
        buf.write("\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138")
        buf.write("\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a")
        buf.write("\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c")
        buf.write("\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e")
        buf.write("\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180")
        buf.write("\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192")
        buf.write("\u0194\u0196\2\25\n\2\26\26\31\3188@@TTXXdehh\4\2##..")
        buf.write("\4\2IIQQ\3\2\u009b\u009c\4\2\u0091\u0092\u009d\u009e\3")
        buf.write("\2\u0086\u0087\3\2\u0088\u008a\20\2\23\23\26\26\31\31")
        buf.write("\36\36##..88@@EETTXX\\\\dehh\4\2\17\17!!\16\2\n\n\20\20")
        buf.write("**::CCJJLPUU[[ggkkmm\5\2IIQQ__\4\2))\66\66\4\2\22\22_")
        buf.write("_\4\2\u0088\u0088\u0093\u0093\4\2\67\67II\4\2++aa\25\2")
        buf.write("\n\n\16\16\22\24\26 \"#%&(\60\63\63\65:<<?@BEGGIKMQSU")
        buf.write("Xikmpp\4\2\4\4\6\6\25\2\13\r\17\21\25\25!!$$\'\'\61\62")
        buf.write("\64\64;;=>AAFFHHLLRRVWjjnoqr\2\u0a2c\2\u0199\3\2\2\2\4")
        buf.write("\u01b1\3\2\2\2\6\u01bd\3\2\2\2\b\u01ca\3\2\2\2\n\u01ce")
        buf.write("\3\2\2\2\f\u01d3\3\2\2\2\16\u01d5\3\2\2\2\20\u01d7\3\2")
        buf.write("\2\2\22\u01dd\3\2\2\2\24\u01df\3\2\2\2\26\u01ea\3\2\2")
        buf.write("\2\30\u01f5\3\2\2\2\32\u0202\3\2\2\2\34\u0207\3\2\2\2")
        buf.write("\36\u0209\3\2\2\2 \u0218\3\2\2\2\"\u021a\3\2\2\2$\u0222")
        buf.write("\3\2\2\2&\u0227\3\2\2\2(\u022f\3\2\2\2*\u0237\3\2\2\2")
        buf.write(",\u023f\3\2\2\2.\u0247\3\2\2\2\60\u024f\3\2\2\2\62\u0257")
        buf.write("\3\2\2\2\64\u0263\3\2\2\2\66\u026e\3\2\2\28\u0276\3\2")
        buf.write("\2\2:\u0296\3\2\2\2<\u0298\3\2\2\2>\u031f\3\2\2\2@\u0322")
        buf.write("\3\2\2\2B\u032a\3\2\2\2D\u033a\3\2\2\2F\u033e\3\2\2\2")
        buf.write("H\u0340\3\2\2\2J\u034a\3\2\2\2L\u034c\3\2\2\2N\u0355\3")
        buf.write("\2\2\2P\u0362\3\2\2\2R\u0369\3\2\2\2T\u036b\3\2\2\2V\u037e")
        buf.write("\3\2\2\2X\u0380\3\2\2\2Z\u0389\3\2\2\2\\\u0396\3\2\2\2")
        buf.write("^\u0398\3\2\2\2`\u03ad\3\2\2\2b\u03b6\3\2\2\2d\u03c2\3")
        buf.write("\2\2\2f\u03d3\3\2\2\2h\u03d5\3\2\2\2j\u03de\3\2\2\2l\u03e3")
        buf.write("\3\2\2\2n\u03ed\3\2\2\2p\u03ef\3\2\2\2r\u03f2\3\2\2\2")
        buf.write("t\u03fd\3\2\2\2v\u0409\3\2\2\2x\u040b\3\2\2\2z\u0410\3")
        buf.write("\2\2\2|\u0413\3\2\2\2~\u0422\3\2\2\2\u0080\u042b\3\2\2")
        buf.write("\2\u0082\u0436\3\2\2\2\u0084\u0438\3\2\2\2\u0086\u0444")
        buf.write("\3\2\2\2\u0088\u0446\3\2\2\2\u008a\u044c\3\2\2\2\u008c")
        buf.write("\u04cd\3\2\2\2\u008e\u04cf\3\2\2\2\u0090\u04d5\3\2\2\2")
        buf.write("\u0092\u04e0\3\2\2\2\u0094\u04e2\3\2\2\2\u0096\u04ea\3")
        buf.write("\2\2\2\u0098\u04ec\3\2\2\2\u009a\u04f2\3\2\2\2\u009c\u04f5")
        buf.write("\3\2\2\2\u009e\u0501\3\2\2\2\u00a0\u0504\3\2\2\2\u00a2")
        buf.write("\u0511\3\2\2\2\u00a4\u0513\3\2\2\2\u00a6\u0526\3\2\2\2")
        buf.write("\u00a8\u0528\3\2\2\2\u00aa\u0534\3\2\2\2\u00ac\u053a\3")
        buf.write("\2\2\2\u00ae\u053f\3\2\2\2\u00b0\u0544\3\2\2\2\u00b2\u0546")
        buf.write("\3\2\2\2\u00b4\u054c\3\2\2\2\u00b6\u0554\3\2\2\2\u00b8")
        buf.write("\u0561\3\2\2\2\u00ba\u0565\3\2\2\2\u00bc\u056b\3\2\2\2")
        buf.write("\u00be\u057e\3\2\2\2\u00c0\u0581\3\2\2\2\u00c2\u0588\3")
        buf.write("\2\2\2\u00c4\u058b\3\2\2\2\u00c6\u0597\3\2\2\2\u00c8\u059d")
        buf.write("\3\2\2\2\u00ca\u05a9\3\2\2\2\u00cc\u05ad\3\2\2\2\u00ce")
        buf.write("\u05b6\3\2\2\2\u00d0\u05bf\3\2\2\2\u00d2\u05c3\3\2\2\2")
        buf.write("\u00d4\u05d2\3\2\2\2\u00d6\u05d7\3\2\2\2\u00d8\u05d9\3")
        buf.write("\2\2\2\u00da\u05e1\3\2\2\2\u00dc\u05e5\3\2\2\2\u00de\u05ec")
        buf.write("\3\2\2\2\u00e0\u05fb\3\2\2\2\u00e2\u05fe\3\2\2\2\u00e4")
        buf.write("\u0602\3\2\2\2\u00e6\u0617\3\2\2\2\u00e8\u0619\3\2\2\2")
        buf.write("\u00ea\u0625\3\2\2\2\u00ec\u062d\3\2\2\2\u00ee\u0631\3")
        buf.write("\2\2\2\u00f0\u0639\3\2\2\2\u00f2\u0640\3\2\2\2\u00f4\u0644")
        buf.write("\3\2\2\2\u00f6\u0646\3\2\2\2\u00f8\u064a\3\2\2\2\u00fa")
        buf.write("\u0652\3\2\2\2\u00fc\u0654\3\2\2\2\u00fe\u0664\3\2\2\2")
        buf.write("\u0100\u0666\3\2\2\2\u0102\u0669\3\2\2\2\u0104\u0670\3")
        buf.write("\2\2\2\u0106\u0682\3\2\2\2\u0108\u068b\3\2\2\2\u010a\u069a")
        buf.write("\3\2\2\2\u010c\u069e\3\2\2\2\u010e\u06a1\3\2\2\2\u0110")
        buf.write("\u06ae\3\2\2\2\u0112\u06b4\3\2\2\2\u0114\u06cf\3\2\2\2")
        buf.write("\u0116\u06d1\3\2\2\2\u0118\u06d8\3\2\2\2\u011a\u06e2\3")
        buf.write("\2\2\2\u011c\u06e4\3\2\2\2\u011e\u06e7\3\2\2\2\u0120\u06f1")
        buf.write("\3\2\2\2\u0122\u0702\3\2\2\2\u0124\u070e\3\2\2\2\u0126")
        buf.write("\u0717\3\2\2\2\u0128\u0727\3\2\2\2\u012a\u0733\3\2\2\2")
        buf.write("\u012c\u073a\3\2\2\2\u012e\u073c\3\2\2\2\u0130\u073f\3")
        buf.write("\2\2\2\u0132\u0749\3\2\2\2\u0134\u0789\3\2\2\2\u0136\u079f")
        buf.write("\3\2\2\2\u0138\u07a2\3\2\2\2\u013a\u07b3\3\2\2\2\u013c")
        buf.write("\u07ba\3\2\2\2\u013e\u07c5\3\2\2\2\u0140\u07c8\3\2\2\2")
        buf.write("\u0142\u07cc\3\2\2\2\u0144\u07da\3\2\2\2\u0146\u07dc\3")
        buf.write("\2\2\2\u0148\u07e4\3\2\2\2\u014a\u07f6\3\2\2\2\u014c\u0809")
        buf.write("\3\2\2\2\u014e\u080b\3\2\2\2\u0150\u0813\3\2\2\2\u0152")
        buf.write("\u081c\3\2\2\2\u0154\u081e\3\2\2\2\u0156\u0823\3\2\2\2")
        buf.write("\u0158\u0829\3\2\2\2\u015a\u082d\3\2\2\2\u015c\u0831\3")
        buf.write("\2\2\2\u015e\u083c\3\2\2\2\u0160\u083e\3\2\2\2\u0162\u0844")
        buf.write("\3\2\2\2\u0164\u0846\3\2\2\2\u0166\u084f\3\2\2\2\u0168")
        buf.write("\u085c\3\2\2\2\u016a\u0862\3\2\2\2\u016c\u0864\3\2\2\2")
        buf.write("\u016e\u0874\3\2\2\2\u0170\u0876\3\2\2\2\u0172\u0885\3")
        buf.write("\2\2\2\u0174\u0894\3\2\2\2\u0176\u08a3\3\2\2\2\u0178\u08ac")
        buf.write("\3\2\2\2\u017a\u08bc\3\2\2\2\u017c\u08c8\3\2\2\2\u017e")
        buf.write("\u08cb\3\2\2\2\u0180\u08db\3\2\2\2\u0182\u08e0\3\2\2\2")
        buf.write("\u0184\u08ee\3\2\2\2\u0186\u08f4\3\2\2\2\u0188\u08ff\3")
        buf.write("\2\2\2\u018a\u0917\3\2\2\2\u018c\u0923\3\2\2\2\u018e\u0933")
        buf.write("\3\2\2\2\u0190\u0939\3\2\2\2\u0192\u093f\3\2\2\2\u0194")
        buf.write("\u0947\3\2\2\2\u0196\u0949\3\2\2\2\u0198\u019a\7\3\2\2")
        buf.write("\u0199\u0198\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019c\3")
        buf.write("\2\2\2\u019b\u019d\5\u00b8]\2\u019c\u019b\3\2\2\2\u019c")
        buf.write("\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e\u01a0\5\u00bc")
        buf.write("_\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a4")
        buf.write("\3\2\2\2\u01a1\u01a3\5\u013c\u009f\2\u01a2\u01a1\3\2\2")
        buf.write("\2\u01a3\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5")
        buf.write("\3\2\2\2\u01a5\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7")
        buf.write("\u01a9\5\u00c0a\2\u01a8\u01a7\3\2\2\2\u01a8\u01a9\3\2")
        buf.write("\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\7\2\2\3\u01ab\3\3")
        buf.write("\2\2\2\u01ac\u01ae\5\u0196\u00cc\2\u01ad\u01af\5\24\13")
        buf.write("\2\u01ae\u01ad\3\2\2\2\u01ae\u01af\3\2\2\2\u01af\u01b2")
        buf.write("\3\2\2\2\u01b0\u01b2\5\u00c6d\2\u01b1\u01ac\3\2\2\2\u01b1")
        buf.write("\u01b0\3\2\2\2\u01b2\u01ba\3\2\2\2\u01b3\u01b4\7\u0082")
        buf.write("\2\2\u01b4\u01b6\5\u0196\u00cc\2\u01b5\u01b7\5\24\13\2")
        buf.write("\u01b6\u01b5\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7\u01b9\3")
        buf.write("\2\2\2\u01b8\u01b3\3\2\2\2\u01b9\u01bc\3\2\2\2\u01ba\u01b8")
        buf.write("\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb\5\3\2\2\2\u01bc\u01ba")
        buf.write("\3\2\2\2\u01bd\u01c3\5\b\5\2\u01be\u01c2\7\u0093\2\2\u01bf")
        buf.write("\u01c2\5\u0124\u0093\2\u01c0\u01c2\7\u0088\2\2\u01c1\u01be")
        buf.write("\3\2\2\2\u01c1\u01bf\3\2\2\2\u01c1\u01c0\3\2\2\2\u01c2")
        buf.write("\u01c5\3\2\2\2\u01c3\u01c1\3\2\2\2\u01c3\u01c4\3\2\2\2")
        buf.write("\u01c4\7\3\2\2\2\u01c5\u01c3\3\2\2\2\u01c6\u01cb\5\n\6")
        buf.write("\2\u01c7\u01cb\5\22\n\2\u01c8\u01c9\7l\2\2\u01c9\u01cb")
        buf.write("\7\u0088\2\2\u01ca\u01c6\3\2\2\2\u01ca\u01c7\3\2\2\2\u01ca")
        buf.write("\u01c8\3\2\2\2\u01cb\t\3\2\2\2\u01cc\u01cf\5\f\7\2\u01cd")
        buf.write("\u01cf\7\23\2\2\u01ce\u01cc\3\2\2\2\u01ce\u01cd\3\2\2")
        buf.write("\2\u01cf\13\3\2\2\2\u01d0\u01d4\5\16\b\2\u01d1\u01d4\5")
        buf.write("\20\t\2\u01d2\u01d4\7\36\2\2\u01d3\u01d0\3\2\2\2\u01d3")
        buf.write("\u01d1\3\2\2\2\u01d3\u01d2\3\2\2\2\u01d4\r\3\2\2\2\u01d5")
        buf.write("\u01d6\t\2\2\2\u01d6\17\3\2\2\2\u01d7\u01d8\t\3\2\2\u01d8")
        buf.write("\21\3\2\2\2\u01d9\u01de\5\4\3\2\u01da\u01de\7E\2\2\u01db")
        buf.write("\u01de\7$\2\2\u01dc\u01de\7\\\2\2\u01dd\u01d9\3\2\2\2")
        buf.write("\u01dd\u01da\3\2\2\2\u01dd\u01db\3\2\2\2\u01dd\u01dc\3")
        buf.write("\2\2\2\u01de\23\3\2\2\2\u01df\u01e0\7\u0091\2\2\u01e0")
        buf.write("\u01e5\5\6\4\2\u01e1\u01e2\7\u0083\2\2\u01e2\u01e4\5\6")
        buf.write("\4\2\u01e3\u01e1\3\2\2\2\u01e4\u01e7\3\2\2\2\u01e5\u01e3")
        buf.write("\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6\u01e8\3\2\2\2\u01e7")
        buf.write("\u01e5\3\2\2\2\u01e8\u01e9\7\u0092\2\2\u01e9\25\3\2\2")
        buf.write("\2\u01ea\u01ef\5\30\r\2\u01eb\u01ec\7\u0083\2\2\u01ec")
        buf.write("\u01ee\5\30\r\2\u01ed\u01eb\3\2\2\2\u01ee\u01f1\3\2\2")
        buf.write("\2\u01ef\u01ed\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0\27\3")
        buf.write("\2\2\2\u01f1\u01ef\3\2\2\2\u01f2\u01f3\5\u0196\u00cc\2")
        buf.write("\u01f3\u01f4\7\u0084\2\2\u01f4\u01f6\3\2\2\2\u01f5\u01f2")
        buf.write("\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f8\3\2\2\2\u01f7")
        buf.write("\u01f9\t\4\2\2\u01f8\u01f7\3\2\2\2\u01f8\u01f9\3\2\2\2")
        buf.write("\u01f9\u01fc\3\2\2\2\u01fa\u01fd\7j\2\2\u01fb\u01fd\5")
        buf.write("\6\4\2\u01fc\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fc\u01fd")
        buf.write("\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u01ff\5\32\16\2\u01ff")
        buf.write("\31\3\2\2\2\u0200\u0203\5\36\20\2\u0201\u0203\5\34\17")
        buf.write("\2\u0202\u0200\3\2\2\2\u0202\u0201\3\2\2\2\u0203\33\3")
        buf.write("\2\2\2\u0204\u0208\5d\63\2\u0205\u0208\5p9\2\u0206\u0208")
        buf.write("\5\"\22\2\u0207\u0204\3\2\2\2\u0207\u0205\3\2\2\2\u0207")
        buf.write("\u0206\3\2\2\2\u0208\35\3\2\2\2\u0209\u020a\5:\36\2\u020a")
        buf.write("\u020b\5 \21\2\u020b\u020c\5\32\16\2\u020c\37\3\2\2\2")
        buf.write("\u020d\u0219\7\u0090\2\2\u020e\u0219\7\u009f\2\2\u020f")
        buf.write("\u0219\7\u00a0\2\2\u0210\u0219\7\u00a1\2\2\u0211\u0219")
        buf.write("\7\u00a2\2\2\u0212\u0219\7\u00a3\2\2\u0213\u0219\7\u00a4")
        buf.write("\2\2\u0214\u0219\7\u00a5\2\2\u0215\u0219\7\u00a6\2\2\u0216")
        buf.write("\u0219\7\u00a8\2\2\u0217\u0219\5\u015c\u00af\2\u0218\u020d")
        buf.write("\3\2\2\2\u0218\u020e\3\2\2\2\u0218\u020f\3\2\2\2\u0218")
        buf.write("\u0210\3\2\2\2\u0218\u0211\3\2\2\2\u0218\u0212\3\2\2\2")
        buf.write("\u0218\u0213\3\2\2\2\u0218\u0214\3\2\2\2\u0218\u0215\3")
        buf.write("\2\2\2\u0218\u0216\3\2\2\2\u0218\u0217\3\2\2\2\u0219!")
        buf.write("\3\2\2\2\u021a\u0220\5$\23\2\u021b\u021c\7\u0093\2\2\u021c")
        buf.write("\u021d\5\32\16\2\u021d\u021e\7\u0084\2\2\u021e\u021f\5")
        buf.write("\32\16\2\u021f\u0221\3\2\2\2\u0220\u021b\3\2\2\2\u0220")
        buf.write("\u0221\3\2\2\2\u0221#\3\2\2\2\u0222\u0225\5&\24\2\u0223")
        buf.write("\u0224\7\u0095\2\2\u0224\u0226\5$\23\2\u0225\u0223\3\2")
        buf.write("\2\2\u0225\u0226\3\2\2\2\u0226%\3\2\2\2\u0227\u022c\5")
        buf.write("(\25\2\u0228\u0229\7\u0099\2\2\u0229\u022b\5(\25\2\u022a")
        buf.write("\u0228\3\2\2\2\u022b\u022e\3\2\2\2\u022c\u022a\3\2\2\2")
        buf.write("\u022c\u022d\3\2\2\2\u022d\'\3\2\2\2\u022e\u022c\3\2\2")
        buf.write("\2\u022f\u0234\5*\26\2\u0230\u0231\7\u0098\2\2\u0231\u0233")
        buf.write("\5*\26\2\u0232\u0230\3\2\2\2\u0233\u0236\3\2\2\2\u0234")
        buf.write("\u0232\3\2\2\2\u0234\u0235\3\2\2\2\u0235)\3\2\2\2\u0236")
        buf.write("\u0234\3\2\2\2\u0237\u023c\5,\27\2\u0238\u0239\7\u008c")
        buf.write("\2\2\u0239\u023b\5,\27\2\u023a\u0238\3\2\2\2\u023b\u023e")
        buf.write("\3\2\2\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2\u023d")
        buf.write("+\3\2\2\2\u023e\u023c\3\2\2\2\u023f\u0244\5.\30\2\u0240")
        buf.write("\u0241\7\u008d\2\2\u0241\u0243\5.\30\2\u0242\u0240\3\2")
        buf.write("\2\2\u0243\u0246\3\2\2\2\u0244\u0242\3\2\2\2\u0244\u0245")
        buf.write("\3\2\2\2\u0245-\3\2\2\2\u0246\u0244\3\2\2\2\u0247\u024c")
        buf.write("\5\60\31\2\u0248\u0249\7\u008b\2\2\u0249\u024b\5\60\31")
        buf.write("\2\u024a\u0248\3\2\2\2\u024b\u024e\3\2\2\2\u024c\u024a")
        buf.write("\3\2\2\2\u024c\u024d\3\2\2\2\u024d/\3\2\2\2\u024e\u024c")
        buf.write("\3\2\2\2\u024f\u0254\5\62\32\2\u0250\u0251\t\5\2\2\u0251")
        buf.write("\u0253\5\62\32\2\u0252\u0250\3\2\2\2\u0253\u0256\3\2\2")
        buf.write("\2\u0254\u0252\3\2\2\2\u0254\u0255\3\2\2\2\u0255\61\3")
        buf.write("\2\2\2\u0256\u0254\3\2\2\2\u0257\u0260\5\64\33\2\u0258")
        buf.write("\u0259\t\6\2\2\u0259\u025f\5\64\33\2\u025a\u025b\7<\2")
        buf.write("\2\u025b\u025f\5b\62\2\u025c\u025d\7\16\2\2\u025d\u025f")
        buf.write("\5\6\4\2\u025e\u0258\3\2\2\2\u025e\u025a\3\2\2\2\u025e")
        buf.write("\u025c\3\2\2\2\u025f\u0262\3\2\2\2\u0260\u025e\3\2\2\2")
        buf.write("\u0260\u0261\3\2\2\2\u0261\63\3\2\2\2\u0262\u0260\3\2")
        buf.write("\2\2\u0263\u026b\5\66\34\2\u0264\u0267\7\u00a7\2\2\u0265")
        buf.write("\u0267\5\u015a\u00ae\2\u0266\u0264\3\2\2\2\u0266\u0265")
        buf.write("\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u026a\5\66\34\2\u0269")
        buf.write("\u0266\3\2\2\2\u026a\u026d\3\2\2\2\u026b\u0269\3\2\2\2")
        buf.write("\u026b\u026c\3\2\2\2\u026c\65\3\2\2\2\u026d\u026b\3\2")
        buf.write("\2\2\u026e\u0273\58\35\2\u026f\u0270\t\7\2\2\u0270\u0272")
        buf.write("\58\35\2\u0271\u026f\3\2\2\2\u0272\u0275\3\2\2\2\u0273")
        buf.write("\u0271\3\2\2\2\u0273\u0274\3\2\2\2\u0274\67\3\2\2\2\u0275")
        buf.write("\u0273\3\2\2\2\u0276\u027b\5:\36\2\u0277\u0278\t\b\2\2")
        buf.write("\u0278\u027a\5:\36\2\u0279\u0277\3\2\2\2\u027a\u027d\3")
        buf.write("\2\2\2\u027b\u0279\3\2\2\2\u027b\u027c\3\2\2\2\u027c9")
        buf.write("\3\2\2\2\u027d\u027b\3\2\2\2\u027e\u0297\5<\37\2\u027f")
        buf.write("\u0280\7\u0086\2\2\u0280\u0297\5:\36\2\u0281\u0282\7\u0087")
        buf.write("\2\2\u0282\u0297\5:\36\2\u0283\u0284\7\u008e\2\2\u0284")
        buf.write("\u0297\5:\36\2\u0285\u0286\7\u008f\2\2\u0286\u0297\5:")
        buf.write("\36\2\u0287\u0288\7\u0096\2\2\u0288\u0297\5:\36\2\u0289")
        buf.write("\u028a\7\u0097\2\2\u028a\u0297\5:\36\2\u028b\u028c\7\u0080")
        buf.write("\2\2\u028c\u028d\5\6\4\2\u028d\u028e\7\u0081\2\2\u028e")
        buf.write("\u028f\5:\36\2\u028f\u0297\3\2\2\2\u0290\u0291\7\21\2")
        buf.write("\2\u0291\u0297\5:\36\2\u0292\u0293\7\u008b\2\2\u0293\u0297")
        buf.write("\5:\36\2\u0294\u0295\7\u0088\2\2\u0295\u0297\5:\36\2\u0296")
        buf.write("\u027e\3\2\2\2\u0296\u027f\3\2\2\2\u0296\u0281\3\2\2\2")
        buf.write("\u0296\u0283\3\2\2\2\u0296\u0285\3\2\2\2\u0296\u0287\3")
        buf.write("\2\2\2\u0296\u0289\3\2\2\2\u0296\u028b\3\2\2\2\u0296\u0290")
        buf.write("\3\2\2\2\u0296\u0292\3\2\2\2\u0296\u0294\3\2\2\2\u0297")
        buf.write(";\3\2\2\2\u0298\u029c\5> \2\u0299\u029b\5B\"\2\u029a\u0299")
        buf.write("\3\2\2\2\u029b\u029e\3\2\2\2\u029c\u029a\3\2\2\2\u029c")
        buf.write("\u029d\3\2\2\2\u029d\u02af\3\2\2\2\u029e\u029c\3\2\2\2")
        buf.write("\u029f\u02a6\5@!\2\u02a0\u02a6\5\u0190\u00c9\2\u02a1\u02a6")
        buf.write("\7\u0096\2\2\u02a2\u02a6\7\u0097\2\2\u02a3\u02a4\7\u009a")
        buf.write("\2\2\u02a4\u02a6\5\u0196\u00cc\2\u02a5\u029f\3\2\2\2\u02a5")
        buf.write("\u02a0\3\2\2\2\u02a5\u02a1\3\2\2\2\u02a5\u02a2\3\2\2\2")
        buf.write("\u02a5\u02a3\3\2\2\2\u02a6\u02aa\3\2\2\2\u02a7\u02a9\5")
        buf.write("B\"\2\u02a8\u02a7\3\2\2\2\u02a9\u02ac\3\2\2\2\u02aa\u02a8")
        buf.write("\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab\u02ae\3\2\2\2\u02ac")
        buf.write("\u02aa\3\2\2\2\u02ad\u02a5\3\2\2\2\u02ae\u02b1\3\2\2\2")
        buf.write("\u02af\u02ad\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0=\3\2\2")
        buf.write("\2\u02b1\u02af\3\2\2\2\u02b2\u0320\5\u015e\u00b0\2\u02b3")
        buf.write("\u02b5\5\u0196\u00cc\2\u02b4\u02b6\5\24\13\2\u02b5\u02b4")
        buf.write("\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6\u0320\3\2\2\2\u02b7")
        buf.write("\u02b8\7\u0080\2\2\u02b8\u02b9\5\32\16\2\u02b9\u02ba\7")
        buf.write("\u0081\2\2\u02ba\u0320\3\2\2\2\u02bb\u0320\5F$\2\u02bc")
        buf.write("\u0320\5\u00c6d\2\u02bd\u0320\7s\2\2\u02be\u0320\7_\2")
        buf.write("\2\u02bf\u02c9\7\22\2\2\u02c0\u02c1\7\u0082\2\2\u02c1")
        buf.write("\u02c3\5\u0196\u00cc\2\u02c2\u02c4\5\24\13\2\u02c3\u02c2")
        buf.write("\3\2\2\2\u02c3\u02c4\3\2\2\2\u02c4\u02ca\3\2\2\2\u02c5")
        buf.write("\u02c6\7~\2\2\u02c6\u02c7\5H%\2\u02c7\u02c8\7\177\2\2")
        buf.write("\u02c8\u02ca\3\2\2\2\u02c9\u02c0\3\2\2\2\u02c9\u02c5\3")
        buf.write("\2\2\2\u02ca\u0320\3\2\2\2\u02cb\u02e8\7C\2\2\u02cc\u02e2")
        buf.write("\5\6\4\2\u02cd\u02e3\5\u0192\u00ca\2\u02ce\u02e3\5J&\2")
        buf.write("\u02cf\u02d0\7~\2\2\u02d0\u02d1\5H%\2\u02d1\u02d5\7\177")
        buf.write("\2\2\u02d2\u02d4\5\u0124\u0093\2\u02d3\u02d2\3\2\2\2\u02d4")
        buf.write("\u02d7\3\2\2\2\u02d5\u02d3\3\2\2\2\u02d5\u02d6\3\2\2\2")
        buf.write("\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8\u02da\5")
        buf.write("\u0126\u0094\2\u02d9\u02d8\3\2\2\2\u02d9\u02da\3\2\2\2")
        buf.write("\u02da\u02e3\3\2\2\2\u02db\u02dd\5\u0124\u0093\2\u02dc")
        buf.write("\u02db\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02dc\3\2\2\2")
        buf.write("\u02de\u02df\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\5")
        buf.write("\u0126\u0094\2\u02e1\u02e3\3\2\2\2\u02e2\u02cd\3\2\2\2")
        buf.write("\u02e2\u02ce\3\2\2\2\u02e2\u02cf\3\2\2\2\u02e2\u02dc\3")
        buf.write("\2\2\2\u02e3\u02e9\3\2\2\2\u02e4\u02e9\5X-\2\u02e5\u02e6")
        buf.write("\5\u0124\u0093\2\u02e6\u02e7\5\u0126\u0094\2\u02e7\u02e9")
        buf.write("\3\2\2\2\u02e8\u02cc\3\2\2\2\u02e8\u02e4\3\2\2\2\u02e8")
        buf.write("\u02e5\3\2\2\2\u02e9\u0320\3\2\2\2\u02ea\u02eb\7c\2\2")
        buf.write("\u02eb\u02ef\7\u0080\2\2\u02ec\u02f0\5^\60\2\u02ed\u02f0")
        buf.write("\5\6\4\2\u02ee\u02f0\7l\2\2\u02ef\u02ec\3\2\2\2\u02ef")
        buf.write("\u02ed\3\2\2\2\u02ef\u02ee\3\2\2\2\u02f0\u02f1\3\2\2\2")
        buf.write("\u02f1\u0320\7\u0081\2\2\u02f2\u02f3\7\32\2\2\u02f3\u02f4")
        buf.write("\7\u0080\2\2\u02f4\u02f5\5\32\16\2\u02f5\u02f6\7\u0081")
        buf.write("\2\2\u02f6\u0320\3\2\2\2\u02f7\u02f8\7f\2\2\u02f8\u02f9")
        buf.write("\7\u0080\2\2\u02f9\u02fa\5\32\16\2\u02fa\u02fb\7\u0081")
        buf.write("\2\2\u02fb\u0320\3\2\2\2\u02fc\u02fd\7\37\2\2\u02fd\u02fe")
        buf.write("\7\u0080\2\2\u02fe\u02ff\5\6\4\2\u02ff\u0300\7\u0081\2")
        buf.write("\2\u0300\u0320\3\2\2\2\u0301\u0303\7\20\2\2\u0302\u0301")
        buf.write("\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0304\3\2\2\2\u0304")
        buf.write("\u030a\7 \2\2\u0305\u0307\7\u0080\2\2\u0306\u0308\5h\65")
        buf.write("\2\u0307\u0306\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u0309")
        buf.write("\3\2\2\2\u0309\u030b\7\u0081\2\2\u030a\u0305\3\2\2\2\u030a")
        buf.write("\u030b\3\2\2\2\u030b\u030c\3\2\2\2\u030c\u0320\5\u008e")
        buf.write("H\2\u030d\u030e\7Y\2\2\u030e\u030f\7\u0080\2\2\u030f\u0310")
        buf.write("\5\6\4\2\u0310\u0311\7\u0081\2\2\u0311\u0320\3\2\2\2\u0312")
        buf.write("\u0313\7A\2\2\u0313\u0319\7\u0080\2\2\u0314\u0315\5\u0196")
        buf.write("\u00cc\2\u0315\u0316\7\u0082\2\2\u0316\u0318\3\2\2\2\u0317")
        buf.write("\u0314\3\2\2\2\u0318\u031b\3\2\2\2\u0319\u0317\3\2\2\2")
        buf.write("\u0319\u031a\3\2\2\2\u031a\u031c\3\2\2\2\u031b\u0319\3")
        buf.write("\2\2\2\u031c\u031d\5\u0196\u00cc\2\u031d\u031e\7\u0081")
        buf.write("\2\2\u031e\u0320\3\2\2\2\u031f\u02b2\3\2\2\2\u031f\u02b3")
        buf.write("\3\2\2\2\u031f\u02b7\3\2\2\2\u031f\u02bb\3\2\2\2\u031f")
        buf.write("\u02bc\3\2\2\2\u031f\u02bd\3\2\2\2\u031f\u02be\3\2\2\2")
        buf.write("\u031f\u02bf\3\2\2\2\u031f\u02cb\3\2\2\2\u031f\u02ea\3")
        buf.write("\2\2\2\u031f\u02f2\3\2\2\2\u031f\u02f7\3\2\2\2\u031f\u02fc")
        buf.write("\3\2\2\2\u031f\u0302\3\2\2\2\u031f\u030d\3\2\2\2\u031f")
        buf.write("\u0312\3\2\2\2\u0320?\3\2\2\2\u0321\u0323\7\u0093\2\2")
        buf.write("\u0322\u0321\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0324\3")
        buf.write("\2\2\2\u0324\u0325\7\u0082\2\2\u0325\u0327\5\u0196\u00cc")
        buf.write("\2\u0326\u0328\5\24\13\2\u0327\u0326\3\2\2\2\u0327\u0328")
        buf.write("\3\2\2\2\u0328A\3\2\2\2\u0329\u032b\7\u0093\2\2\u032a")
        buf.write("\u0329\3\2\2\2\u032a\u032b\3\2\2\2\u032b\u032c\3\2\2\2")
        buf.write("\u032c\u032d\7~\2\2\u032d\u0332\5D#\2\u032e\u032f\7\u0083")
        buf.write("\2\2\u032f\u0331\5D#\2\u0330\u032e\3\2\2\2\u0331\u0334")
        buf.write("\3\2\2\2\u0332\u0330\3\2\2\2\u0332\u0333\3\2\2\2\u0333")
        buf.write("\u0335\3\2\2\2\u0334\u0332\3\2\2\2\u0335\u0336\7\177\2")
        buf.write("\2\u0336C\3\2\2\2\u0337\u0338\5\u0196\u00cc\2\u0338\u0339")
        buf.write("\7\u0084\2\2\u0339\u033b\3\2\2\2\u033a\u0337\3\2\2\2\u033a")
        buf.write("\u033b\3\2\2\2\u033b\u033c\3\2\2\2\u033c\u033d\5\32\16")
        buf.write("\2\u033dE\3\2\2\2\u033e\u033f\t\t\2\2\u033fG\3\2\2\2\u0340")
        buf.write("\u0345\5\32\16\2\u0341\u0342\7\u0083\2\2\u0342\u0344\5")
        buf.write("\32\16\2\u0343\u0341\3\2\2\2\u0344\u0347\3\2\2\2\u0345")
        buf.write("\u0343\3\2\2\2\u0345\u0346\3\2\2\2\u0346I\3\2\2\2\u0347")
        buf.write("\u0345\3\2\2\2\u0348\u034b\5L\'\2\u0349\u034b\5T+\2\u034a")
        buf.write("\u0348\3\2\2\2\u034a\u0349\3\2\2\2\u034bK\3\2\2\2\u034c")
        buf.write("\u0351\7|\2\2\u034d\u034f\5N(\2\u034e\u0350\7\u0083\2")
        buf.write("\2\u034f\u034e\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0352")
        buf.write("\3\2\2\2\u0351\u034d\3\2\2\2\u0351\u0352\3\2\2\2\u0352")
        buf.write("\u0353\3\2\2\2\u0353\u0354\7}\2\2\u0354M\3\2\2\2\u0355")
        buf.write("\u035a\5P)\2\u0356\u0357\7\u0083\2\2\u0357\u0359\5P)\2")
        buf.write("\u0358\u0356\3\2\2\2\u0359\u035c\3\2\2\2\u035a\u0358\3")
        buf.write("\2\2\2\u035a\u035b\3\2\2\2\u035bO\3\2\2\2\u035c\u035a")
        buf.write("\3\2\2\2\u035d\u0363\5\u0196\u00cc\2\u035e\u035f\7~\2")
        buf.write("\2\u035f\u0360\5\32\16\2\u0360\u0361\7\177\2\2\u0361\u0363")
        buf.write("\3\2\2\2\u0362\u035d\3\2\2\2\u0362\u035e\3\2\2\2\u0363")
        buf.write("\u0364\3\2\2\2\u0364\u0365\7\u0090\2\2\u0365\u0366\5R")
        buf.write("*\2\u0366Q\3\2\2\2\u0367\u036a\5\32\16\2\u0368\u036a\5")
        buf.write("J&\2\u0369\u0367\3\2\2\2\u0369\u0368\3\2\2\2\u036aS\3")
        buf.write("\2\2\2\u036b\u036c\7|\2\2\u036c\u0371\5V,\2\u036d\u036e")
        buf.write("\7\u0083\2\2\u036e\u0370\5V,\2\u036f\u036d\3\2\2\2\u0370")
        buf.write("\u0373\3\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2")
        buf.write("\u0372\u0375\3\2\2\2\u0373\u0371\3\2\2\2\u0374\u0376\7")
        buf.write("\u0083\2\2\u0375\u0374\3\2\2\2\u0375\u0376\3\2\2\2\u0376")
        buf.write("\u0377\3\2\2\2\u0377\u0378\7}\2\2\u0378U\3\2\2\2\u0379")
        buf.write("\u037f\5\34\17\2\u037a\u037b\7|\2\2\u037b\u037c\5H%\2")
        buf.write("\u037c\u037d\7}\2\2\u037d\u037f\3\2\2\2\u037e\u0379\3")
        buf.write("\2\2\2\u037e\u037a\3\2\2\2\u037fW\3\2\2\2\u0380\u0385")
        buf.write("\7|\2\2\u0381\u0383\5Z.\2\u0382\u0384\7\u0083\2\2\u0383")
        buf.write("\u0382\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0386\3\2\2\2")
        buf.write("\u0385\u0381\3\2\2\2\u0385\u0386\3\2\2\2\u0386\u0387\3")
        buf.write("\2\2\2\u0387\u0388\7}\2\2\u0388Y\3\2\2\2\u0389\u038e\5")
        buf.write("\\/\2\u038a\u038b\7\u0083\2\2\u038b\u038d\5\\/\2\u038c")
        buf.write("\u038a\3\2\2\2\u038d\u0390\3\2\2\2\u038e\u038c\3\2\2\2")
        buf.write("\u038e\u038f\3\2\2\2\u038f[\3\2\2\2\u0390\u038e\3\2\2")
        buf.write("\2\u0391\u0397\5<\37\2\u0392\u0393\5\u0196\u00cc\2\u0393")
        buf.write("\u0394\7\u0090\2\2\u0394\u0395\5\32\16\2\u0395\u0397\3")
        buf.write("\2\2\2\u0396\u0391\3\2\2\2\u0396\u0392\3\2\2\2\u0397]")
        buf.write("\3\2\2\2\u0398\u03a1\5\u0196\u00cc\2\u0399\u039b\5`\61")
        buf.write("\2\u039a\u0399\3\2\2\2\u039a\u039b\3\2\2\2\u039b\u03a2")
        buf.write("\3\2\2\2\u039c\u039d\7\u0094\2\2\u039d\u039f\5\u0196\u00cc")
        buf.write("\2\u039e\u03a0\5`\61\2\u039f\u039e\3\2\2\2\u039f\u03a0")
        buf.write("\3\2\2\2\u03a0\u03a2\3\2\2\2\u03a1\u039a\3\2\2\2\u03a1")
        buf.write("\u039c\3\2\2\2\u03a2\u03aa\3\2\2\2\u03a3\u03a4\7\u0082")
        buf.write("\2\2\u03a4\u03a6\5\u0196\u00cc\2\u03a5\u03a7\5`\61\2\u03a6")
        buf.write("\u03a5\3\2\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03a9\3\2\2\2")
        buf.write("\u03a8\u03a3\3\2\2\2\u03a9\u03ac\3\2\2\2\u03aa\u03a8\3")
        buf.write("\2\2\2\u03aa\u03ab\3\2\2\2\u03ab_\3\2\2\2\u03ac\u03aa")
        buf.write("\3\2\2\2\u03ad\u03b1\7\u0091\2\2\u03ae\u03b0\7\u0083\2")
        buf.write("\2\u03af\u03ae\3\2\2\2\u03b0\u03b3\3\2\2\2\u03b1\u03af")
        buf.write("\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b4\3\2\2\2\u03b3")
        buf.write("\u03b1\3\2\2\2\u03b4\u03b5\7\u0092\2\2\u03b5a\3\2\2\2")
        buf.write("\u03b6\u03bb\5\b\5\2\u03b7\u03ba\5\u0124\u0093\2\u03b8")
        buf.write("\u03ba\7\u0088\2\2\u03b9\u03b7\3\2\2\2\u03b9\u03b8\3\2")
        buf.write("\2\2\u03ba\u03bd\3\2\2\2\u03bb\u03b9\3\2\2\2\u03bb\u03bc")
        buf.write("\3\2\2\2\u03bc\u03bf\3\2\2\2\u03bd\u03bb\3\2\2\2\u03be")
        buf.write("\u03c0\7\u0093\2\2\u03bf\u03be\3\2\2\2\u03bf\u03c0\3\2")
        buf.write("\2\2\u03c0c\3\2\2\2\u03c1\u03c3\7\20\2\2\u03c2\u03c1\3")
        buf.write("\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c4\3\2\2\2\u03c4\u03c5")
        buf.write("\5f\64\2\u03c5\u03c6\5\u0158\u00ad\2\u03c6\u03c7\5n8\2")
        buf.write("\u03c7e\3\2\2\2\u03c8\u03c9\7\u0080\2\2\u03c9\u03d4\7")
        buf.write("\u0081\2\2\u03ca\u03cb\7\u0080\2\2\u03cb\u03cc\5h\65\2")
        buf.write("\u03cc\u03cd\7\u0081\2\2\u03cd\u03d4\3\2\2\2\u03ce\u03cf")
        buf.write("\7\u0080\2\2\u03cf\u03d0\5l\67\2\u03d0\u03d1\7\u0081\2")
        buf.write("\2\u03d1\u03d4\3\2\2\2\u03d2\u03d4\5\u0196\u00cc\2\u03d3")
        buf.write("\u03c8\3\2\2\2\u03d3\u03ca\3\2\2\2\u03d3\u03ce\3\2\2\2")
        buf.write("\u03d3\u03d2\3\2\2\2\u03d4g\3\2\2\2\u03d5\u03da\5j\66")
        buf.write("\2\u03d6\u03d7\7\u0083\2\2\u03d7\u03d9\5j\66\2\u03d8\u03d6")
        buf.write("\3\2\2\2\u03d9\u03dc\3\2\2\2\u03da\u03d8\3\2\2\2\u03da")
        buf.write("\u03db\3\2\2\2\u03dbi\3\2\2\2\u03dc\u03da\3\2\2\2\u03dd")
        buf.write("\u03df\t\4\2\2\u03de\u03dd\3\2\2\2\u03de\u03df\3\2\2\2")
        buf.write("\u03df\u03e0\3\2\2\2\u03e0\u03e1\5\6\4\2\u03e1\u03e2\5")
        buf.write("\u0196\u00cc\2\u03e2k\3\2\2\2\u03e3\u03e8\5\u0196\u00cc")
        buf.write("\2\u03e4\u03e5\7\u0083\2\2\u03e5\u03e7\5\u0196\u00cc\2")
        buf.write("\u03e6\u03e4\3\2\2\2\u03e7\u03ea\3\2\2\2\u03e8\u03e6\3")
        buf.write("\2\2\2\u03e8\u03e9\3\2\2\2\u03e9m\3\2\2\2\u03ea\u03e8")
        buf.write("\3\2\2\2\u03eb\u03ee\5\32\16\2\u03ec\u03ee\5\u008eH\2")
        buf.write("\u03ed\u03eb\3\2\2\2\u03ed\u03ec\3\2\2\2\u03eeo\3\2\2")
        buf.write("\2\u03ef\u03f0\5r:\2\u03f0\u03f1\5t;\2\u03f1q\3\2\2\2")
        buf.write("\u03f2\u03f4\7\61\2\2\u03f3\u03f5\5\6\4\2\u03f4\u03f3")
        buf.write("\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6")
        buf.write("\u03f7\5\u0196\u00cc\2\u03f7\u03f8\7\67\2\2\u03f8\u03f9")
        buf.write("\5\32\16\2\u03f9s\3\2\2\2\u03fa\u03fc\5v<\2\u03fb\u03fa")
        buf.write("\3\2\2\2\u03fc\u03ff\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fd")
        buf.write("\u03fe\3\2\2\2\u03fe\u0400\3\2\2\2\u03ff\u03fd\3\2\2\2")
        buf.write("\u0400\u0402\5\u0082B\2\u0401\u0403\5\u0084C\2\u0402\u0401")
        buf.write("\3\2\2\2\u0402\u0403\3\2\2\2\u0403u\3\2\2\2\u0404\u040a")
        buf.write("\5r:\2\u0405\u040a\5x=\2\u0406\u040a\5z>\2\u0407\u040a")
        buf.write("\5|?\2\u0408\u040a\5~@\2\u0409\u0404\3\2\2\2\u0409\u0405")
        buf.write("\3\2\2\2\u0409\u0406\3\2\2\2\u0409\u0407\3\2\2\2\u0409")
        buf.write("\u0408\3\2\2\2\u040aw\3\2\2\2\u040b\u040c\7>\2\2\u040c")
        buf.write("\u040d\5\u0196\u00cc\2\u040d\u040e\7\u0090\2\2\u040e\u040f")
        buf.write("\5\32\16\2\u040fy\3\2\2\2\u0410\u0411\7o\2\2\u0411\u0412")
        buf.write("\5\32\16\2\u0412{\3\2\2\2\u0413\u0415\7=\2\2\u0414\u0416")
        buf.write("\5\6\4\2\u0415\u0414\3\2\2\2\u0415\u0416\3\2\2\2\u0416")
        buf.write("\u0417\3\2\2\2\u0417\u0418\5\u0196\u00cc\2\u0418\u0419")
        buf.write("\7\67\2\2\u0419\u041a\5\32\16\2\u041a\u041b\7F\2\2\u041b")
        buf.write("\u041c\5\32\16\2\u041c\u041d\7\'\2\2\u041d\u0420\5\32")
        buf.write("\16\2\u041e\u041f\7;\2\2\u041f\u0421\5\u0196\u00cc\2\u0420")
        buf.write("\u041e\3\2\2\2\u0420\u0421\3\2\2\2\u0421}\3\2\2\2\u0422")
        buf.write("\u0423\7H\2\2\u0423\u0428\5\u0080A\2\u0424\u0425\7\u0083")
        buf.write("\2\2\u0425\u0427\5\u0080A\2\u0426\u0424\3\2\2\2\u0427")
        buf.write("\u042a\3\2\2\2\u0428\u0426\3\2\2\2\u0428\u0429\3\2\2\2")
        buf.write("\u0429\177\3\2\2\2\u042a\u0428\3\2\2\2\u042b\u042d\5\32")
        buf.write("\16\2\u042c\u042e\t\n\2\2\u042d\u042c\3\2\2\2\u042d\u042e")
        buf.write("\3\2\2\2\u042e\u0081\3\2\2\2\u042f\u0430\7V\2\2\u0430")
        buf.write("\u0437\5\32\16\2\u0431\u0432\7\64\2\2\u0432\u0433\5\32")
        buf.write("\16\2\u0433\u0434\7\25\2\2\u0434\u0435\5\32\16\2\u0435")
        buf.write("\u0437\3\2\2\2\u0436\u042f\3\2\2\2\u0436\u0431\3\2\2\2")
        buf.write("\u0437\u0083\3\2\2\2\u0438\u0439\7;\2\2\u0439\u043a\5")
        buf.write("\u0196\u00cc\2\u043a\u043b\5t;\2\u043b\u0085\3\2\2\2\u043c")
        buf.write("\u0445\5\u0088E\2\u043d\u0440\5\u0090I\2\u043e\u0440\5")
        buf.write("\u0098M\2\u043f\u043d\3\2\2\2\u043f\u043e\3\2\2\2\u0440")
        buf.write("\u0441\3\2\2\2\u0441\u0442\7\u0085\2\2\u0442\u0445\3\2")
        buf.write("\2\2\u0443\u0445\5\u008aF\2\u0444\u043c\3\2\2\2\u0444")
        buf.write("\u043f\3\2\2\2\u0444\u0443\3\2\2\2\u0445\u0087\3\2\2\2")
        buf.write("\u0446\u0447\5\u0196\u00cc\2\u0447\u0448\7\u0084\2\2\u0448")
        buf.write("\u0449\5\u0086D\2\u0449\u0089\3\2\2\2\u044a\u044d\5\u008e")
        buf.write("H\2\u044b\u044d\5\u008cG\2\u044c\u044a\3\2\2\2\u044c\u044b")
        buf.write("\3\2\2\2\u044d\u008b\3\2\2\2\u044e\u04ce\7\u0085\2\2\u044f")
        buf.write("\u0450\5\32\16\2\u0450\u0451\7\u0085\2\2\u0451\u04ce\3")
        buf.write("\2\2\2\u0452\u0453\7\65\2\2\u0453\u0454\7\u0080\2\2\u0454")
        buf.write("\u0455\5\32\16\2\u0455\u0456\7\u0081\2\2\u0456\u0459\5")
        buf.write("\u009aN\2\u0457\u0458\7%\2\2\u0458\u045a\5\u009aN\2\u0459")
        buf.write("\u0457\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u04ce\3\2\2\2")
        buf.write("\u045b\u045c\7^\2\2\u045c\u045d\7\u0080\2\2\u045d\u045e")
        buf.write("\5\32\16\2\u045e\u045f\7\u0081\2\2\u045f\u0463\7|\2\2")
        buf.write("\u0460\u0462\5\u009cO\2\u0461\u0460\3\2\2\2\u0462\u0465")
        buf.write("\3\2\2\2\u0463\u0461\3\2\2\2\u0463\u0464\3\2\2\2\u0464")
        buf.write("\u0466\3\2\2\2\u0465\u0463\3\2\2\2\u0466\u0467\7}\2\2")
        buf.write("\u0467\u04ce\3\2\2\2\u0468\u0469\7p\2\2\u0469\u046a\7")
        buf.write("\u0080\2\2\u046a\u046b\5\32\16\2\u046b\u046c\7\u0081\2")
        buf.write("\2\u046c\u046d\5\u008aF\2\u046d\u04ce\3\2\2\2\u046e\u046f")
        buf.write("\7\"\2\2\u046f\u0470\5\u008aF\2\u0470\u0471\7p\2\2\u0471")
        buf.write("\u0472\7\u0080\2\2\u0472\u0473\5\32\16\2\u0473\u0474\7")
        buf.write("\u0081\2\2\u0474\u0475\7\u0085\2\2\u0475\u04ce\3\2\2\2")
        buf.write("\u0476\u0477\7/\2\2\u0477\u0479\7\u0080\2\2\u0478\u047a")
        buf.write("\5\u00a2R\2\u0479\u0478\3\2\2\2\u0479\u047a\3\2\2\2\u047a")
        buf.write("\u047b\3\2\2\2\u047b\u047d\7\u0085\2\2\u047c\u047e\5\32")
        buf.write("\16\2\u047d\u047c\3\2\2\2\u047d\u047e\3\2\2\2\u047e\u047f")
        buf.write("\3\2\2\2\u047f\u0481\7\u0085\2\2\u0480\u0482\5\u00a4S")
        buf.write("\2\u0481\u0480\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u0483")
        buf.write("\3\2\2\2\u0483\u0484\7\u0081\2\2\u0484\u04ce\5\u008aF")
        buf.write("\2\u0485\u0486\7\60\2\2\u0486\u0487\7\u0080\2\2\u0487")
        buf.write("\u0488\5\u0092J\2\u0488\u0489\5\u0196\u00cc\2\u0489\u048a")
        buf.write("\7\67\2\2\u048a\u048b\5\32\16\2\u048b\u048c\7\u0081\2")
        buf.write("\2\u048c\u048d\5\u008aF\2\u048d\u04ce\3\2\2\2\u048e\u048f")
        buf.write("\7\24\2\2\u048f\u04ce\7\u0085\2\2\u0490\u0491\7\35\2\2")
        buf.write("\u0491\u04ce\7\u0085\2\2\u0492\u0497\7\63\2\2\u0493\u0498")
        buf.write("\5\u0196\u00cc\2\u0494\u0495\7\27\2\2\u0495\u0498\5\32")
        buf.write("\16\2\u0496\u0498\7\37\2\2\u0497\u0493\3\2\2\2\u0497\u0494")
        buf.write("\3\2\2\2\u0497\u0496\3\2\2\2\u0498\u0499\3\2\2\2\u0499")
        buf.write("\u04ce\7\u0085\2\2\u049a\u049c\7S\2\2\u049b\u049d\5\32")
        buf.write("\16\2\u049c\u049b\3\2\2\2\u049c\u049d\3\2\2\2\u049d\u049e")
        buf.write("\3\2\2\2\u049e\u04ce\7\u0085\2\2\u049f\u04a1\7`\2\2\u04a0")
        buf.write("\u04a2\5\32\16\2\u04a1\u04a0\3\2\2\2\u04a1\u04a2\3\2\2")
        buf.write("\2\u04a2\u04a3\3\2\2\2\u04a3\u04ce\7\u0085\2\2\u04a4\u04a5")
        buf.write("\7b\2\2\u04a5\u04ab\5\u008eH\2\u04a6\u04a8\5\u00a6T\2")
        buf.write("\u04a7\u04a9\5\u00aeX\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9")
        buf.write("\3\2\2\2\u04a9\u04ac\3\2\2\2\u04aa\u04ac\5\u00aeX\2\u04ab")
        buf.write("\u04a6\3\2\2\2\u04ab\u04aa\3\2\2\2\u04ac\u04ce\3\2\2\2")
        buf.write("\u04ad\u04ae\7\32\2\2\u04ae\u04ce\5\u008eH\2\u04af\u04b0")
        buf.write("\7f\2\2\u04b0\u04ce\5\u008eH\2\u04b1\u04b2\7?\2\2\u04b2")
        buf.write("\u04b3\7\u0080\2\2\u04b3\u04b4\5\32\16\2\u04b4\u04b5\7")
        buf.write("\u0081\2\2\u04b5\u04b6\5\u008aF\2\u04b6\u04ce\3\2\2\2")
        buf.write("\u04b7\u04b8\7i\2\2\u04b8\u04b9\7\u0080\2\2\u04b9\u04ba")
        buf.write("\5\u00b0Y\2\u04ba\u04bb\7\u0081\2\2\u04bb\u04bc\5\u008a")
        buf.write("F\2\u04bc\u04ce\3\2\2\2\u04bd\u04c1\7q\2\2\u04be\u04bf")
        buf.write("\7S\2\2\u04bf\u04c2\5\32\16\2\u04c0\u04c2\7\24\2\2\u04c1")
        buf.write("\u04be\3\2\2\2\u04c1\u04c0\3\2\2\2\u04c2\u04c3\3\2\2\2")
        buf.write("\u04c3\u04ce\7\u0085\2\2\u04c4\u04c5\7g\2\2\u04c5\u04ce")
        buf.write("\5\u008eH\2\u04c6\u04c7\7-\2\2\u04c7\u04c8\7\u0080\2\2")
        buf.write("\u04c8\u04c9\5\u014c\u00a7\2\u04c9\u04ca\5\u014e\u00a8")
        buf.write("\2\u04ca\u04cb\7\u0081\2\2\u04cb\u04cc\5\u008aF\2\u04cc")
        buf.write("\u04ce\3\2\2\2\u04cd\u044e\3\2\2\2\u04cd\u044f\3\2\2\2")
        buf.write("\u04cd\u0452\3\2\2\2\u04cd\u045b\3\2\2\2\u04cd\u0468\3")
        buf.write("\2\2\2\u04cd\u046e\3\2\2\2\u04cd\u0476\3\2\2\2\u04cd\u0485")
        buf.write("\3\2\2\2\u04cd\u048e\3\2\2\2\u04cd\u0490\3\2\2\2\u04cd")
        buf.write("\u0492\3\2\2\2\u04cd\u049a\3\2\2\2\u04cd\u049f\3\2\2\2")
        buf.write("\u04cd\u04a4\3\2\2\2\u04cd\u04ad\3\2\2\2\u04cd\u04af\3")
        buf.write("\2\2\2\u04cd\u04b1\3\2\2\2\u04cd\u04b7\3\2\2\2\u04cd\u04bd")
        buf.write("\3\2\2\2\u04cd\u04c4\3\2\2\2\u04cd\u04c6\3\2\2\2\u04ce")
        buf.write("\u008d\3\2\2\2\u04cf\u04d1\7|\2\2\u04d0\u04d2\5\u00a0")
        buf.write("Q\2\u04d1\u04d0\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3")
        buf.write("\3\2\2\2\u04d3\u04d4\7}\2\2\u04d4\u008f\3\2\2\2\u04d5")
        buf.write("\u04d6\5\u0092J\2\u04d6\u04db\5\u0094K\2\u04d7\u04d8\7")
        buf.write("\u0083\2\2\u04d8\u04da\5\u0094K\2\u04d9\u04d7\3\2\2\2")
        buf.write("\u04da\u04dd\3\2\2\2\u04db\u04d9\3\2\2\2\u04db\u04dc\3")
        buf.write("\2\2\2\u04dc\u0091\3\2\2\2\u04dd\u04db\3\2\2\2\u04de\u04e1")
        buf.write("\7j\2\2\u04df\u04e1\5\6\4\2\u04e0\u04de\3\2\2\2\u04e0")
        buf.write("\u04df\3\2\2\2\u04e1\u0093\3\2\2\2\u04e2\u04e5\5\u0196")
        buf.write("\u00cc\2\u04e3\u04e4\7\u0090\2\2\u04e4\u04e6\5\u0096L")
        buf.write("\2\u04e5\u04e3\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u0095")
        buf.write("\3\2\2\2\u04e7\u04eb\5\32\16\2\u04e8\u04eb\5\u0126\u0094")
        buf.write("\2\u04e9\u04eb\5\u0156\u00ac\2\u04ea\u04e7\3\2\2\2\u04ea")
        buf.write("\u04e8\3\2\2\2\u04ea\u04e9\3\2\2\2\u04eb\u0097\3\2\2\2")
        buf.write("\u04ec\u04ed\7\34\2\2\u04ed\u04ee\5\6\4\2\u04ee\u04ef")
        buf.write("\5\u00eav\2\u04ef\u0099\3\2\2\2\u04f0\u04f3\5\u008eH\2")
        buf.write("\u04f1\u04f3\5\u008cG\2\u04f2\u04f0\3\2\2\2\u04f2\u04f1")
        buf.write("\3\2\2\2\u04f3\u009b\3\2\2\2\u04f4\u04f6\5\u009eP\2\u04f5")
        buf.write("\u04f4\3\2\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04f5\3\2\2\2")
        buf.write("\u04f7\u04f8\3\2\2\2\u04f8\u04f9\3\2\2\2\u04f9\u04fa\5")
        buf.write("\u00a0Q\2\u04fa\u009d\3\2\2\2\u04fb\u04fc\7\27\2\2\u04fc")
        buf.write("\u04fd\5\32\16\2\u04fd\u04fe\7\u0084\2\2\u04fe\u0502\3")
        buf.write("\2\2\2\u04ff\u0500\7\37\2\2\u0500\u0502\7\u0084\2\2\u0501")
        buf.write("\u04fb\3\2\2\2\u0501\u04ff\3\2\2\2\u0502\u009f\3\2\2\2")
        buf.write("\u0503\u0505\5\u0086D\2\u0504\u0503\3\2\2\2\u0505\u0506")
        buf.write("\3\2\2\2\u0506\u0504\3\2\2\2\u0506\u0507\3\2\2\2\u0507")
        buf.write("\u00a1\3\2\2\2\u0508\u0512\5\u0090I\2\u0509\u050e\5\32")
        buf.write("\16\2\u050a\u050b\7\u0083\2\2\u050b\u050d\5\32\16\2\u050c")
        buf.write("\u050a\3\2\2\2\u050d\u0510\3\2\2\2\u050e\u050c\3\2\2\2")
        buf.write("\u050e\u050f\3\2\2\2\u050f\u0512\3\2\2\2\u0510\u050e\3")
        buf.write("\2\2\2\u0511\u0508\3\2\2\2\u0511\u0509\3\2\2\2\u0512\u00a3")
        buf.write("\3\2\2\2\u0513\u0518\5\32\16\2\u0514\u0515\7\u0083\2\2")
        buf.write("\u0515\u0517\5\32\16\2\u0516\u0514\3\2\2\2\u0517\u051a")
        buf.write("\3\2\2\2\u0518\u0516\3\2\2\2\u0518\u0519\3\2\2\2\u0519")
        buf.write("\u00a5\3\2\2\2\u051a\u0518\3\2\2\2\u051b\u051f\5\u00a8")
        buf.write("U\2\u051c\u051e\5\u00a8U\2\u051d\u051c\3\2\2\2\u051e\u0521")
        buf.write("\3\2\2\2\u051f\u051d\3\2\2\2\u051f\u0520\3\2\2\2\u0520")
        buf.write("\u0523\3\2\2\2\u0521\u051f\3\2\2\2\u0522\u0524\5\u00aa")
        buf.write("V\2\u0523\u0522\3\2\2\2\u0523\u0524\3\2\2\2\u0524\u0527")
        buf.write("\3\2\2\2\u0525\u0527\5\u00aaV\2\u0526\u051b\3\2\2\2\u0526")
        buf.write("\u0525\3\2\2\2\u0527\u00a7\3\2\2\2\u0528\u0529\7\30\2")
        buf.write("\2\u0529\u052a\7\u0080\2\2\u052a\u052c\5\22\n\2\u052b")
        buf.write("\u052d\5\u0196\u00cc\2\u052c\u052b\3\2\2\2\u052c\u052d")
        buf.write("\3\2\2\2\u052d\u052e\3\2\2\2\u052e\u0530\7\u0081\2\2\u052f")
        buf.write("\u0531\5\u00acW\2\u0530\u052f\3\2\2\2\u0530\u0531\3\2")
        buf.write("\2\2\u0531\u0532\3\2\2\2\u0532\u0533\5\u008eH\2\u0533")
        buf.write("\u00a9\3\2\2\2\u0534\u0536\7\30\2\2\u0535\u0537\5\u00ac")
        buf.write("W\2\u0536\u0535\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0538")
        buf.write("\3\2\2\2\u0538\u0539\5\u008eH\2\u0539\u00ab\3\2\2\2\u053a")
        buf.write("\u053b\7n\2\2\u053b\u053c\7\u0080\2\2\u053c\u053d\5\32")
        buf.write("\16\2\u053d\u053e\7\u0081\2\2\u053e\u00ad\3\2\2\2\u053f")
        buf.write("\u0540\7,\2\2\u0540\u0541\5\u008eH\2\u0541\u00af\3\2\2")
        buf.write("\2\u0542\u0545\5\u0090I\2\u0543\u0545\5\32\16\2\u0544")
        buf.write("\u0542\3\2\2\2\u0544\u0543\3\2\2\2\u0545\u00b1\3\2\2\2")
        buf.write("\u0546\u0547\7B\2\2\u0547\u0548\5\u00b4[\2\u0548\u054a")
        buf.write("\5\u00b6\\\2\u0549\u054b\7\u0085\2\2\u054a\u0549\3\2\2")
        buf.write("\2\u054a\u054b\3\2\2\2\u054b\u00b3\3\2\2\2\u054c\u0551")
        buf.write("\5\u0196\u00cc\2\u054d\u054e\7\u0082\2\2\u054e\u0550\5")
        buf.write("\u0196\u00cc\2\u054f\u054d\3\2\2\2\u0550\u0553\3\2\2\2")
        buf.write("\u0551\u054f\3\2\2\2\u0551\u0552\3\2\2\2\u0552\u00b5\3")
        buf.write("\2\2\2\u0553\u0551\3\2\2\2\u0554\u0556\7|\2\2\u0555\u0557")
        buf.write("\5\u00b8]\2\u0556\u0555\3\2\2\2\u0556\u0557\3\2\2\2\u0557")
        buf.write("\u0559\3\2\2\2\u0558\u055a\5\u00bc_\2\u0559\u0558\3\2")
        buf.write("\2\2\u0559\u055a\3\2\2\2\u055a\u055c\3\2\2\2\u055b\u055d")
        buf.write("\5\u00c0a\2\u055c\u055b\3\2\2\2\u055c\u055d\3\2\2\2\u055d")
        buf.write("\u055e\3\2\2\2\u055e\u055f\7}\2\2\u055f\u00b7\3\2\2\2")
        buf.write("\u0560\u0562\5\u00ba^\2\u0561\u0560\3\2\2\2\u0562\u0563")
        buf.write("\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564")
        buf.write("\u00b9\3\2\2\2\u0565\u0566\7*\2\2\u0566\u0567\7\f\2\2")
        buf.write("\u0567\u0568\5\u0196\u00cc\2\u0568\u0569\7\u0085\2\2\u0569")
        buf.write("\u00bb\3\2\2\2\u056a\u056c\5\u00be`\2\u056b\u056a\3\2")
        buf.write("\2\2\u056c\u056d\3\2\2\2\u056d\u056b\3\2\2\2\u056d\u056e")
        buf.write("\3\2\2\2\u056e\u00bd\3\2\2\2\u056f\u0570\7i\2\2\u0570")
        buf.write("\u0571\5\u0196\u00cc\2\u0571\u0572\7\u0090\2\2\u0572\u0573")
        buf.write("\5\4\3\2\u0573\u0574\7\u0085\2\2\u0574\u057f\3\2\2\2\u0575")
        buf.write("\u0576\7i\2\2\u0576\u0577\5\4\3\2\u0577\u0578\7\u0085")
        buf.write("\2\2\u0578\u057f\3\2\2\2\u0579\u057a\7i\2\2\u057a\u057b")
        buf.write("\7[\2\2\u057b\u057c\5\4\3\2\u057c\u057d\7\u0085\2\2\u057d")
        buf.write("\u057f\3\2\2\2\u057e\u056f\3\2\2\2\u057e\u0575\3\2\2\2")
        buf.write("\u057e\u0579\3\2\2\2\u057f\u00bf\3\2\2\2\u0580\u0582\5")
        buf.write("\u00c2b\2\u0581\u0580\3\2\2\2\u0582\u0583\3\2\2\2\u0583")
        buf.write("\u0581\3\2\2\2\u0583\u0584\3\2\2\2\u0584\u00c1\3\2\2\2")
        buf.write("\u0585\u0589\5\u00b2Z\2\u0586\u0589\5\u00c4c\2\u0587\u0589")
        buf.write("\5\u0194\u00cb\2\u0588\u0585\3\2\2\2\u0588\u0586\3\2\2")
        buf.write("\2\u0588\u0587\3\2\2\2\u0589\u00c3\3\2\2\2\u058a\u058c")
        buf.write("\5\u0140\u00a1\2\u058b\u058a\3\2\2\2\u058b\u058c\3\2\2")
        buf.write("\2\u058c\u058e\3\2\2\2\u058d\u058f\5\u00e2r\2\u058e\u058d")
        buf.write("\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0595\3\2\2\2\u0590")
        buf.write("\u0596\5\u0170\u00b9\2\u0591\u0596\5\u0172\u00ba\2\u0592")
        buf.write("\u0596\5\u0174\u00bb\2\u0593\u0596\5\u0176\u00bc\2\u0594")
        buf.write("\u0596\5\u0178\u00bd\2\u0595\u0590\3\2\2\2\u0595\u0591")
        buf.write("\3\2\2\2\u0595\u0592\3\2\2\2\u0595\u0593\3\2\2\2\u0595")
        buf.write("\u0594\3\2\2\2\u0596\u00c5\3\2\2\2\u0597\u0598\5\u0196")
        buf.write("\u00cc\2\u0598\u0599\7\u0094\2\2\u0599\u059b\5\u0196\u00cc")
        buf.write("\2\u059a\u059c\5\24\13\2\u059b\u059a\3\2\2\2\u059b\u059c")
        buf.write("\3\2\2\2\u059c\u00c7\3\2\2\2\u059d\u059e\7\u0091\2\2\u059e")
        buf.write("\u05a3\5\u00caf\2\u059f\u05a0\7\u0083\2\2\u05a0\u05a2")
        buf.write("\5\u00caf\2\u05a1\u059f\3\2\2\2\u05a2\u05a5\3\2\2\2\u05a3")
        buf.write("\u05a1\3\2\2\2\u05a3\u05a4\3\2\2\2\u05a4\u05a6\3\2\2\2")
        buf.write("\u05a5\u05a3\3\2\2\2\u05a6\u05a7\7\u0092\2\2\u05a7\u00c9")
        buf.write("\3\2\2\2\u05a8\u05aa\5\u0140\u00a1\2\u05a9\u05a8\3\2\2")
        buf.write("\2\u05a9\u05aa\3\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05ac")
        buf.write("\5\u0196\u00cc\2\u05ac\u00cb\3\2\2\2\u05ad\u05ae\7\u0084")
        buf.write("\2\2\u05ae\u05b3\5\22\n\2\u05af\u05b0\7\u0083\2\2\u05b0")
        buf.write("\u05b2\5\4\3\2\u05b1\u05af\3\2\2\2\u05b2\u05b5\3\2\2\2")
        buf.write("\u05b3\u05b1\3\2\2\2\u05b3\u05b4\3\2\2\2\u05b4\u00cd\3")
        buf.write("\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05bb\5\4\3\2\u05b7\u05b8")
        buf.write("\7\u0083\2\2\u05b8\u05ba\5\4\3\2\u05b9\u05b7\3\2\2\2\u05ba")
        buf.write("\u05bd\3\2\2\2\u05bb\u05b9\3\2\2\2\u05bb\u05bc\3\2\2\2")
        buf.write("\u05bc\u00cf\3\2\2\2\u05bd\u05bb\3\2\2\2\u05be\u05c0\5")
        buf.write("\u00d2j\2\u05bf\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1")
        buf.write("\u05bf\3\2\2\2\u05c1\u05c2\3\2\2\2\u05c2\u00d1\3\2\2\2")
        buf.write("\u05c3\u05c4\7o\2\2\u05c4\u05c5\5\u0196\u00cc\2\u05c5")
        buf.write("\u05c6\7\u0084\2\2\u05c6\u05c7\5\u00d4k\2\u05c7\u00d3")
        buf.write("\3\2\2\2\u05c8\u05d3\5\u00dan\2\u05c9\u05cc\5\u00d6l\2")
        buf.write("\u05ca\u05cb\7\u0083\2\2\u05cb\u05cd\5\u00d8m\2\u05cc")
        buf.write("\u05ca\3\2\2\2\u05cc\u05cd\3\2\2\2\u05cd\u05d0\3\2\2\2")
        buf.write("\u05ce\u05cf\7\u0083\2\2\u05cf\u05d1\5\u00dan\2\u05d0")
        buf.write("\u05ce\3\2\2\2\u05d0\u05d1\3\2\2\2\u05d1\u05d3\3\2\2\2")
        buf.write("\u05d2\u05c8\3\2\2\2\u05d2\u05c9\3\2\2\2\u05d3\u00d5\3")
        buf.write("\2\2\2\u05d4\u05d8\5\22\n\2\u05d5\u05d8\7\33\2\2\u05d6")
        buf.write("\u05d8\7]\2\2\u05d7\u05d4\3\2\2\2\u05d7\u05d5\3\2\2\2")
        buf.write("\u05d7\u05d6\3\2\2\2\u05d8\u00d7\3\2\2\2\u05d9\u05de\5")
        buf.write("\4\3\2\u05da\u05db\7\u0083\2\2\u05db\u05dd\5\4\3\2\u05dc")
        buf.write("\u05da\3\2\2\2\u05dd\u05e0\3\2\2\2\u05de\u05dc\3\2\2\2")
        buf.write("\u05de\u05df\3\2\2\2\u05df\u00d9\3\2\2\2\u05e0\u05de\3")
        buf.write("\2\2\2\u05e1\u05e2\7C\2\2\u05e2\u05e3\7\u0080\2\2\u05e3")
        buf.write("\u05e4\7\u0081\2\2\u05e4\u00db\3\2\2\2\u05e5\u05e7\7|")
        buf.write("\2\2\u05e6\u05e8\5\u00dep\2\u05e7\u05e6\3\2\2\2\u05e7")
        buf.write("\u05e8\3\2\2\2\u05e8\u05e9\3\2\2\2\u05e9\u05ea\7}\2\2")
        buf.write("\u05ea\u00dd\3\2\2\2\u05eb\u05ed\5\u00e0q\2\u05ec\u05eb")
        buf.write("\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee\u05ec\3\2\2\2\u05ee")
        buf.write("\u05ef\3\2\2\2\u05ef\u00df\3\2\2\2\u05f0\u05fc\5\u0194")
        buf.write("\u00cb\2\u05f1\u05f3\5\u0140\u00a1\2\u05f2\u05f1\3\2\2")
        buf.write("\2\u05f2\u05f3\3\2\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f6")
        buf.write("\5\u00e2r\2\u05f5\u05f4\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6")
        buf.write("\u05f9\3\2\2\2\u05f7\u05fa\5\u00e6t\2\u05f8\u05fa\5\u0184")
        buf.write("\u00c3\2\u05f9\u05f7\3\2\2\2\u05f9\u05f8\3\2\2\2\u05fa")
        buf.write("\u05fc\3\2\2\2\u05fb\u05f0\3\2\2\2\u05fb\u05f2\3\2\2\2")
        buf.write("\u05fc\u00e1\3\2\2\2\u05fd\u05ff\5\u00e4s\2\u05fe\u05fd")
        buf.write("\3\2\2\2\u05ff\u0600\3\2\2\2\u0600\u05fe\3\2\2\2\u0600")
        buf.write("\u0601\3\2\2\2\u0601\u00e3\3\2\2\2\u0602\u0603\t\13\2")
        buf.write("\2\u0603\u00e5\3\2\2\2\u0604\u0618\5\u0180\u00c1\2\u0605")
        buf.write("\u0618\5\u00e8u\2\u0606\u0618\5\u017a\u00be\2\u0607\u060d")
        buf.write("\5\u0116\u008c\2\u0608\u060e\5\u011a\u008e\2\u0609\u060a")
        buf.write("\5\u0158\u00ad\2\u060a\u060b\5\32\16\2\u060b\u060c\7\u0085")
        buf.write("\2\2\u060c\u060e\3\2\2\2\u060d\u0608\3\2\2\2\u060d\u0609")
        buf.write("\3\2\2\2\u060e\u0618\3\2\2\2\u060f\u0618\5\u0186\u00c4")
        buf.write("\2\u0610\u0611\7l\2\2\u0611\u0618\5\u0188\u00c5\2\u0612")
        buf.write("\u0618\5\u0170\u00b9\2\u0613\u0618\5\u0172\u00ba\2\u0614")
        buf.write("\u0618\5\u0174\u00bb\2\u0615\u0618\5\u0176\u00bc\2\u0616")
        buf.write("\u0618\5\u0178\u00bd\2\u0617\u0604\3\2\2\2\u0617\u0605")
        buf.write("\3\2\2\2\u0617\u0606\3\2\2\2\u0617\u0607\3\2\2\2\u0617")
        buf.write("\u060f\3\2\2\2\u0617\u0610\3\2\2\2\u0617\u0612\3\2\2\2")
        buf.write("\u0617\u0613\3\2\2\2\u0617\u0614\3\2\2\2\u0617\u0615\3")
        buf.write("\2\2\2\u0617\u0616\3\2\2\2\u0618\u00e7\3\2\2\2\u0619\u0623")
        buf.write("\5\6\4\2\u061a\u061b\5\4\3\2\u061b\u061c\7\u0082\2\2\u061c")
        buf.write("\u061d\5\u0182\u00c2\2\u061d\u0624\3\2\2\2\u061e\u0624")
        buf.write("\5\u0188\u00c5\2\u061f\u0624\5\u017e\u00c0\2\u0620\u0624")
        buf.write("\5\u0182\u00c2\2\u0621\u0624\5\u018c\u00c7\2\u0622\u0624")
        buf.write("\5\u017c\u00bf\2\u0623\u061a\3\2\2\2\u0623\u061e\3\2\2")
        buf.write("\2\u0623\u061f\3\2\2\2\u0623\u0620\3\2\2\2\u0623\u0621")
        buf.write("\3\2\2\2\u0623\u0622\3\2\2\2\u0624\u00e9\3\2\2\2\u0625")
        buf.write("\u062a\5\u00ecw\2\u0626\u0627\7\u0083\2\2\u0627\u0629")
        buf.write("\5\u00ecw\2\u0628\u0626\3\2\2\2\u0629\u062c\3\2\2\2\u062a")
        buf.write("\u0628\3\2\2\2\u062a\u062b\3\2\2\2\u062b\u00eb\3\2\2\2")
        buf.write("\u062c\u062a\3\2\2\2\u062d\u062e\5\u0196\u00cc\2\u062e")
        buf.write("\u062f\7\u0090\2\2\u062f\u0630\5\32\16\2\u0630\u00ed\3")
        buf.write("\2\2\2\u0631\u0636\5\u00f0y\2\u0632\u0633\7\u0083\2\2")
        buf.write("\u0633\u0635\5\u00f0y\2\u0634\u0632\3\2\2\2\u0635\u0638")
        buf.write("\3\2\2\2\u0636\u0634\3\2\2\2\u0636\u0637\3\2\2\2\u0637")
        buf.write("\u00ef\3\2\2\2\u0638\u0636\3\2\2\2\u0639\u063c\5\u0196")
        buf.write("\u00cc\2\u063a\u063b\7\u0090\2\2\u063b\u063d\5\u00f2z")
        buf.write("\2\u063c\u063a\3\2\2\2\u063c\u063d\3\2\2\2\u063d\u00f1")
        buf.write("\3\2\2\2\u063e\u0641\5\32\16\2\u063f\u0641\5\u0126\u0094")
        buf.write("\2\u0640\u063e\3\2\2\2\u0640\u063f\3\2\2\2\u0641\u00f3")
        buf.write("\3\2\2\2\u0642\u0645\5\6\4\2\u0643\u0645\7l\2\2\u0644")
        buf.write("\u0642\3\2\2\2\u0644\u0643\3\2\2\2\u0645\u00f5\3\2\2\2")
        buf.write("\u0646\u0647\5\4\3\2\u0647\u00f7\3\2\2\2\u0648\u064b\5")
        buf.write("\u008eH\2\u0649\u064b\7\u0085\2\2\u064a\u0648\3\2\2\2")
        buf.write("\u064a\u0649\3\2\2\2\u064b\u00f9\3\2\2\2\u064c\u0653\5")
        buf.write("\u0102\u0082\2\u064d\u0650\5\u00fc\177\2\u064e\u064f\7")
        buf.write("\u0083\2\2\u064f\u0651\5\u0102\u0082\2\u0650\u064e\3\2")
        buf.write("\2\2\u0650\u0651\3\2\2\2\u0651\u0653\3\2\2\2\u0652\u064c")
        buf.write("\3\2\2\2\u0652\u064d\3\2\2\2\u0653\u00fb\3\2\2\2\u0654")
        buf.write("\u0659\5\u00fe\u0080\2\u0655\u0656\7\u0083\2\2\u0656\u0658")
        buf.write("\5\u00fe\u0080\2\u0657\u0655\3\2\2\2\u0658\u065b\3\2\2")
        buf.write("\2\u0659\u0657\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u00fd")
        buf.write("\3\2\2\2\u065b\u0659\3\2\2\2\u065c\u065e\5\u0140\u00a1")
        buf.write("\2\u065d\u065c\3\2\2\2\u065d\u065e\3\2\2\2\u065e\u0660")
        buf.write("\3\2\2\2\u065f\u0661\5\u0100\u0081\2\u0660\u065f\3\2\2")
        buf.write("\2\u0660\u0661\3\2\2\2\u0661\u0662\3\2\2\2\u0662\u0665")
        buf.write("\5\u018e\u00c8\2\u0663\u0665\7\r\2\2\u0664\u065d\3\2\2")
        buf.write("\2\u0664\u0663\3\2\2\2\u0665\u00ff\3\2\2\2\u0666\u0667")
        buf.write("\t\f\2\2\u0667\u0101\3\2\2\2\u0668\u066a\5\u0140\u00a1")
        buf.write("\2\u0669\u0668\3\2\2\2\u0669\u066a\3\2\2\2\u066a\u066b")
        buf.write("\3\2\2\2\u066b\u066c\7K\2\2\u066c\u066d\5\u0122\u0092")
        buf.write("\2\u066d\u066e\5\u0196\u00cc\2\u066e\u0103\3\2\2\2\u066f")
        buf.write("\u0671\5\u0140\u00a1\2\u0670\u066f\3\2\2\2\u0670\u0671")
        buf.write("\3\2\2\2\u0671\u0673\3\2\2\2\u0672\u0674\5\u010a\u0086")
        buf.write("\2\u0673\u0672\3\2\2\2\u0673\u0674\3\2\2\2\u0674\u067f")
        buf.write("\3\2\2\2\u0675\u0676\7\62\2\2\u0676\u0678\5\u010c\u0087")
        buf.write("\2\u0677\u0679\5\u0108\u0085\2\u0678\u0677\3\2\2\2\u0678")
        buf.write("\u0679\3\2\2\2\u0679\u0680\3\2\2\2\u067a\u067b\7W\2\2")
        buf.write("\u067b\u067d\5\u010c\u0087\2\u067c\u067e\5\u0106\u0084")
        buf.write("\2\u067d\u067c\3\2\2\2\u067d\u067e\3\2\2\2\u067e\u0680")
        buf.write("\3\2\2\2\u067f\u0675\3\2\2\2\u067f\u067a\3\2\2\2\u0680")
        buf.write("\u0105\3\2\2\2\u0681\u0683\5\u0140\u00a1\2\u0682\u0681")
        buf.write("\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0685\3\2\2\2\u0684")
        buf.write("\u0686\5\u010a\u0086\2\u0685\u0684\3\2\2\2\u0685\u0686")
        buf.write("\3\2\2\2\u0686\u0687\3\2\2\2\u0687\u0688\7\62\2\2\u0688")
        buf.write("\u0689\5\u010c\u0087\2\u0689\u0107\3\2\2\2\u068a\u068c")
        buf.write("\5\u0140\u00a1\2\u068b\u068a\3\2\2\2\u068b\u068c\3\2\2")
        buf.write("\2\u068c\u068e\3\2\2\2\u068d\u068f\5\u010a\u0086\2\u068e")
        buf.write("\u068d\3\2\2\2\u068e\u068f\3\2\2\2\u068f\u0690\3\2\2\2")
        buf.write("\u0690\u0691\7W\2\2\u0691\u0692\5\u010c\u0087\2\u0692")
        buf.write("\u0109\3\2\2\2\u0693\u069b\7N\2\2\u0694\u069b\7:\2\2\u0695")
        buf.write("\u069b\7M\2\2\u0696\u0697\7N\2\2\u0697\u069b\7:\2\2\u0698")
        buf.write("\u0699\7:\2\2\u0699\u069b\7N\2\2\u069a\u0693\3\2\2\2\u069a")
        buf.write("\u0694\3\2\2\2\u069a\u0695\3\2\2\2\u069a\u0696\3\2\2\2")
        buf.write("\u069a\u0698\3\2\2\2\u069b\u010b\3\2\2\2\u069c\u069f\5")
        buf.write("\u008eH\2\u069d\u069f\7\u0085\2\2\u069e\u069c\3\2\2\2")
        buf.write("\u069e\u069d\3\2\2\2\u069f\u010d\3\2\2\2\u06a0\u06a2\5")
        buf.write("\u0140\u00a1\2\u06a1\u06a0\3\2\2\2\u06a1\u06a2\3\2\2\2")
        buf.write("\u06a2\u06ab\3\2\2\2\u06a3\u06a4\7\13\2\2\u06a4\u06a5")
        buf.write("\5\u008eH\2\u06a5\u06a6\5\u0112\u008a\2\u06a6\u06ac\3")
        buf.write("\2\2\2\u06a7\u06a8\7R\2\2\u06a8\u06a9\5\u008eH\2\u06a9")
        buf.write("\u06aa\5\u0110\u0089\2\u06aa\u06ac\3\2\2\2\u06ab\u06a3")
        buf.write("\3\2\2\2\u06ab\u06a7\3\2\2\2\u06ac\u010f\3\2\2\2\u06ad")
        buf.write("\u06af\5\u0140\u00a1\2\u06ae\u06ad\3\2\2\2\u06ae\u06af")
        buf.write("\3\2\2\2\u06af\u06b0\3\2\2\2\u06b0\u06b1\7\13\2\2\u06b1")
        buf.write("\u06b2\5\u008eH\2\u06b2\u0111\3\2\2\2\u06b3\u06b5\5\u0140")
        buf.write("\u00a1\2\u06b4\u06b3\3\2\2\2\u06b4\u06b5\3\2\2\2\u06b5")
        buf.write("\u06b6\3\2\2\2\u06b6\u06b7\7R\2\2\u06b7\u06b8\5\u008e")
        buf.write("H\2\u06b8\u0113\3\2\2\2\u06b9\u06d0\7\u0086\2\2\u06ba")
        buf.write("\u06d0\7\u0087\2\2\u06bb\u06d0\7\u008e\2\2\u06bc\u06d0")
        buf.write("\7\u008f\2\2\u06bd\u06d0\7\u0096\2\2\u06be\u06d0\7\u0097")
        buf.write("\2\2\u06bf\u06d0\7a\2\2\u06c0\u06d0\7+\2\2\u06c1\u06d0")
        buf.write("\7\u0088\2\2\u06c2\u06d0\7\u0089\2\2\u06c3\u06d0\7\u008a")
        buf.write("\2\2\u06c4\u06d0\7\u008b\2\2\u06c5\u06d0\7\u008c\2\2\u06c6")
        buf.write("\u06d0\7\u008d\2\2\u06c7\u06d0\7\u00a7\2\2\u06c8\u06d0")
        buf.write("\5\u015a\u00ae\2\u06c9\u06d0\7\u009b\2\2\u06ca\u06d0\7")
        buf.write("\u009c\2\2\u06cb\u06d0\7\u0092\2\2\u06cc\u06d0\7\u0091")
        buf.write("\2\2\u06cd\u06d0\7\u009e\2\2\u06ce\u06d0\7\u009d\2\2\u06cf")
        buf.write("\u06b9\3\2\2\2\u06cf\u06ba\3\2\2\2\u06cf\u06bb\3\2\2\2")
        buf.write("\u06cf\u06bc\3\2\2\2\u06cf\u06bd\3\2\2\2\u06cf\u06be\3")
        buf.write("\2\2\2\u06cf\u06bf\3\2\2\2\u06cf\u06c0\3\2\2\2\u06cf\u06c1")
        buf.write("\3\2\2\2\u06cf\u06c2\3\2\2\2\u06cf\u06c3\3\2\2\2\u06cf")
        buf.write("\u06c4\3\2\2\2\u06cf\u06c5\3\2\2\2\u06cf\u06c6\3\2\2\2")
        buf.write("\u06cf\u06c7\3\2\2\2\u06cf\u06c8\3\2\2\2\u06cf\u06c9\3")
        buf.write("\2\2\2\u06cf\u06ca\3\2\2\2\u06cf\u06cb\3\2\2\2\u06cf\u06cc")
        buf.write("\3\2\2\2\u06cf\u06cd\3\2\2\2\u06cf\u06ce\3\2\2\2\u06d0")
        buf.write("\u0115\3\2\2\2\u06d1\u06d2\t\r\2\2\u06d2\u06d3\7G\2\2")
        buf.write("\u06d3\u06d4\5\6\4\2\u06d4\u06d5\7\u0080\2\2\u06d5\u06d6")
        buf.write("\5\u018e\u00c8\2\u06d6\u06d7\7\u0081\2\2\u06d7\u0117\3")
        buf.write("\2\2\2\u06d8\u06d9\7\u0084\2\2\u06d9\u06da\t\16\2\2\u06da")
        buf.write("\u06dc\7\u0080\2\2\u06db\u06dd\5\26\f\2\u06dc\u06db\3")
        buf.write("\2\2\2\u06dc\u06dd\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u06df")
        buf.write("\7\u0081\2\2\u06df\u0119\3\2\2\2\u06e0\u06e3\5\u008eH")
        buf.write("\2\u06e1\u06e3\7\u0085\2\2\u06e2\u06e0\3\2\2\2\u06e2\u06e1")
        buf.write("\3\2\2\2\u06e3\u011b\3\2\2\2\u06e4\u06e5\7\u0084\2\2\u06e5")
        buf.write("\u06e6\5\u00ceh\2\u06e6\u011d\3\2\2\2\u06e7\u06eb\7|\2")
        buf.write("\2\u06e8\u06ea\5\u0120\u0091\2\u06e9\u06e8\3\2\2\2\u06ea")
        buf.write("\u06ed\3\2\2\2\u06eb\u06e9\3\2\2\2\u06eb\u06ec\3\2\2\2")
        buf.write("\u06ec\u06ee\3\2\2\2\u06ed\u06eb\3\2\2\2\u06ee\u06ef\7")
        buf.write("}\2\2\u06ef\u011f\3\2\2\2\u06f0\u06f2\5\u0140\u00a1\2")
        buf.write("\u06f1\u06f0\3\2\2\2\u06f1\u06f2\3\2\2\2\u06f2\u06f4\3")
        buf.write("\2\2\2\u06f3\u06f5\5\u00e2r\2\u06f4\u06f3\3\2\2\2\u06f4")
        buf.write("\u06f5\3\2\2\2\u06f5\u0700\3\2\2\2\u06f6\u0701\5\u00e6")
        buf.write("t\2\u06f7\u06f8\7-\2\2\u06f8\u06fa\5\6\4\2\u06f9\u06fb")
        buf.write("\5\u0154\u00ab\2\u06fa\u06f9\3\2\2\2\u06fb\u06fc\3\2\2")
        buf.write("\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd\3\2\2\2\u06fd\u06fe")
        buf.write("\3\2\2\2\u06fe\u06ff\7\u0085\2\2\u06ff\u0701\3\2\2\2\u0700")
        buf.write("\u06f6\3\2\2\2\u0700\u06f7\3\2\2\2\u0701\u0121\3\2\2\2")
        buf.write("\u0702\u070a\5\b\5\2\u0703\u0705\t\17\2\2\u0704\u0703")
        buf.write("\3\2\2\2\u0705\u0708\3\2\2\2\u0706\u0704\3\2\2\2\u0706")
        buf.write("\u0707\3\2\2\2\u0707\u0709\3\2\2\2\u0708\u0706\3\2\2\2")
        buf.write("\u0709\u070b\5\u0124\u0093\2\u070a\u0706\3\2\2\2\u070b")
        buf.write("\u070c\3\2\2\2\u070c\u070a\3\2\2\2\u070c\u070d\3\2\2\2")
        buf.write("\u070d\u0123\3\2\2\2\u070e\u0712\7~\2\2\u070f\u0711\7")
        buf.write("\u0083\2\2\u0710\u070f\3\2\2\2\u0711\u0714\3\2\2\2\u0712")
        buf.write("\u0710\3\2\2\2\u0712\u0713\3\2\2\2\u0713\u0715\3\2\2\2")
        buf.write("\u0714\u0712\3\2\2\2\u0715\u0716\7\177\2\2\u0716\u0125")
        buf.write("\3\2\2\2\u0717\u0723\7|\2\2\u0718\u071d\5\u00f2z\2\u0719")
        buf.write("\u071a\7\u0083\2\2\u071a\u071c\5\u00f2z\2\u071b\u0719")
        buf.write("\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d")
        buf.write("\u071e\3\2\2\2\u071e\u0721\3\2\2\2\u071f\u071d\3\2\2\2")
        buf.write("\u0720\u0722\7\u0083\2\2\u0721\u0720\3\2\2\2\u0721\u0722")
        buf.write("\3\2\2\2\u0722\u0724\3\2\2\2\u0723\u0718\3\2\2\2\u0723")
        buf.write("\u0724\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u0726\7}\2\2")
        buf.write("\u0726\u0127\3\2\2\2\u0727\u0728\7\u0091\2\2\u0728\u072d")
        buf.write("\5\u012a\u0096\2\u0729\u072a\7\u0083\2\2\u072a\u072c\5")
        buf.write("\u012a\u0096\2\u072b\u0729\3\2\2\2\u072c\u072f\3\2\2\2")
        buf.write("\u072d\u072b\3\2\2\2\u072d\u072e\3\2\2\2\u072e\u0730\3")
        buf.write("\2\2\2\u072f\u072d\3\2\2\2\u0730\u0731\7\u0092\2\2\u0731")
        buf.write("\u0129\3\2\2\2\u0732\u0734\5\u0140\u00a1\2\u0733\u0732")
        buf.write("\3\2\2\2\u0733\u0734\3\2\2\2\u0734\u0736\3\2\2\2\u0735")
        buf.write("\u0737\5\u012c\u0097\2\u0736\u0735\3\2\2\2\u0736\u0737")
        buf.write("\3\2\2\2\u0737\u0738\3\2\2\2\u0738\u0739\5\u0196\u00cc")
        buf.write("\2\u0739\u012b\3\2\2\2\u073a\u073b\t\20\2\2\u073b\u012d")
        buf.write("\3\2\2\2\u073c\u073d\7\u0084\2\2\u073d\u073e\5\u00ceh")
        buf.write("\2\u073e\u012f\3\2\2\2\u073f\u0743\7|\2\2\u0740\u0742")
        buf.write("\5\u0132\u009a\2\u0741\u0740\3\2\2\2\u0742\u0745\3\2\2")
        buf.write("\2\u0743\u0741\3\2\2\2\u0743\u0744\3\2\2\2\u0744\u0746")
        buf.write("\3\2\2\2\u0745\u0743\3\2\2\2\u0746\u0747\7}\2\2\u0747")
        buf.write("\u0131\3\2\2\2\u0748\u074a\5\u0140\u00a1\2\u0749\u0748")
        buf.write("\3\2\2\2\u0749\u074a\3\2\2\2\u074a\u074c\3\2\2\2\u074b")
        buf.write("\u074d\7C\2\2\u074c\u074b\3\2\2\2\u074c\u074d\3\2\2\2")
        buf.write("\u074d\u0786\3\2\2\2\u074e\u0750\7g\2\2\u074f\u074e\3")
        buf.write("\2\2\2\u074f\u0750\3\2\2\2\u0750\u0751\3\2\2\2\u0751\u076d")
        buf.write("\5\6\4\2\u0752\u0754\5\u0196\u00cc\2\u0753\u0755\5\u00c8")
        buf.write("e\2\u0754\u0753\3\2\2\2\u0754\u0755\3\2\2\2\u0755\u0756")
        buf.write("\3\2\2\2\u0756\u0758\7\u0080\2\2\u0757\u0759\5\u00fa~")
        buf.write("\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2\2\u0759\u075a")
        buf.write("\3\2\2\2\u075a\u075c\7\u0081\2\2\u075b\u075d\5\u00d0i")
        buf.write("\2\u075c\u075b\3\2\2\2\u075c\u075d\3\2\2\2\u075d\u075e")
        buf.write("\3\2\2\2\u075e\u075f\7\u0085\2\2\u075f\u076e\3\2\2\2\u0760")
        buf.write("\u0761\5\u0196\u00cc\2\u0761\u0762\7|\2\2\u0762\u0763")
        buf.write("\5\u0134\u009b\2\u0763\u0764\7}\2\2\u0764\u076e\3\2\2")
        buf.write("\2\u0765\u0766\7_\2\2\u0766\u0767\7~\2\2\u0767\u0768\5")
        buf.write("\u00fa~\2\u0768\u0769\7\177\2\2\u0769\u076a\7|\2\2\u076a")
        buf.write("\u076b\5\u0134\u009b\2\u076b\u076c\7}\2\2\u076c\u076e")
        buf.write("\3\2\2\2\u076d\u0752\3\2\2\2\u076d\u0760\3\2\2\2\u076d")
        buf.write("\u0765\3\2\2\2\u076e\u0787\3\2\2\2\u076f\u0771\7g\2\2")
        buf.write("\u0770\u076f\3\2\2\2\u0770\u0771\3\2\2\2\u0771\u0772\3")
        buf.write("\2\2\2\u0772\u0773\7l\2\2\u0773\u0775\5\u0196\u00cc\2")
        buf.write("\u0774\u0776\5\u00c8e\2\u0775\u0774\3\2\2\2\u0775\u0776")
        buf.write("\3\2\2\2\u0776\u0777\3\2\2\2\u0777\u0779\7\u0080\2\2\u0778")
        buf.write("\u077a\5\u00fa~\2\u0779\u0778\3\2\2\2\u0779\u077a\3\2")
        buf.write("\2\2\u077a\u077b\3\2\2\2\u077b\u077d\7\u0081\2\2\u077c")
        buf.write("\u077e\5\u00d0i\2\u077d\u077c\3\2\2\2\u077d\u077e\3\2")
        buf.write("\2\2\u077e\u077f\3\2\2\2\u077f\u0780\7\u0085\2\2\u0780")
        buf.write("\u0787\3\2\2\2\u0781\u0782\7(\2\2\u0782\u0783\5\6\4\2")
        buf.write("\u0783\u0784\5\u0196\u00cc\2\u0784\u0785\7\u0085\2\2\u0785")
        buf.write("\u0787\3\2\2\2\u0786\u074f\3\2\2\2\u0786\u0770\3\2\2\2")
        buf.write("\u0786\u0781\3\2\2\2\u0787\u0133\3\2\2\2\u0788\u078a\5")
        buf.write("\u0140\u00a1\2\u0789\u0788\3\2\2\2\u0789\u078a\3\2\2\2")
        buf.write("\u078a\u079d\3\2\2\2\u078b\u078c\7\62\2\2\u078c\u0792")
        buf.write("\7\u0085\2\2\u078d\u078f\5\u0140\u00a1\2\u078e\u078d\3")
        buf.write("\2\2\2\u078e\u078f\3\2\2\2\u078f\u0790\3\2\2\2\u0790\u0791")
        buf.write("\7W\2\2\u0791\u0793\7\u0085\2\2\u0792\u078e\3\2\2\2\u0792")
        buf.write("\u0793\3\2\2\2\u0793\u079e\3\2\2\2\u0794\u0795\7W\2\2")
        buf.write("\u0795\u079b\7\u0085\2\2\u0796\u0798\5\u0140\u00a1\2\u0797")
        buf.write("\u0796\3\2\2\2\u0797\u0798\3\2\2\2\u0798\u0799\3\2\2\2")
        buf.write("\u0799\u079a\7\62\2\2\u079a\u079c\7\u0085\2\2\u079b\u0797")
        buf.write("\3\2\2\2\u079b\u079c\3\2\2\2\u079c\u079e\3\2\2\2\u079d")
        buf.write("\u078b\3\2\2\2\u079d\u0794\3\2\2\2\u079e\u0135\3\2\2\2")
        buf.write("\u079f\u07a0\7\u0084\2\2\u07a0\u07a1\5\6\4\2\u07a1\u0137")
        buf.write("\3\2\2\2\u07a2\u07ae\7|\2\2\u07a3\u07a8\5\u013a\u009e")
        buf.write("\2\u07a4\u07a5\7\u0083\2\2\u07a5\u07a7\5\u013a\u009e\2")
        buf.write("\u07a6\u07a4\3\2\2\2\u07a7\u07aa\3\2\2\2\u07a8\u07a6\3")
        buf.write("\2\2\2\u07a8\u07a9\3\2\2\2\u07a9\u07ac\3\2\2\2\u07aa\u07a8")
        buf.write("\3\2\2\2\u07ab\u07ad\7\u0083\2\2\u07ac\u07ab\3\2\2\2\u07ac")
        buf.write("\u07ad\3\2\2\2\u07ad\u07af\3\2\2\2\u07ae\u07a3\3\2\2\2")
        buf.write("\u07ae\u07af\3\2\2\2\u07af\u07b0\3\2\2\2\u07b0\u07b1\7")
        buf.write("}\2\2\u07b1\u0139\3\2\2\2\u07b2\u07b4\5\u0140\u00a1\2")
        buf.write("\u07b3\u07b2\3\2\2\2\u07b3\u07b4\3\2\2\2\u07b4\u07b5\3")
        buf.write("\2\2\2\u07b5\u07b8\5\u0196\u00cc\2\u07b6\u07b7\7\u0090")
        buf.write("\2\2\u07b7\u07b9\5\32\16\2\u07b8\u07b6\3\2\2\2\u07b8\u07b9")
        buf.write("\3\2\2\2\u07b9\u013b\3\2\2\2\u07ba\u07bb\7~\2\2\u07bb")
        buf.write("\u07bc\5\u013e\u00a0\2\u07bc\u07bd\7\u0084\2\2\u07bd\u07bf")
        buf.write("\5\u0146\u00a4\2\u07be\u07c0\7\u0083\2\2\u07bf\u07be\3")
        buf.write("\2\2\2\u07bf\u07c0\3\2\2\2\u07c0\u07c1\3\2\2\2\u07c1\u07c2")
        buf.write("\7\177\2\2\u07c2\u013d\3\2\2\2\u07c3\u07c6\5\u016e\u00b8")
        buf.write("\2\u07c4\u07c6\5\u0196\u00cc\2\u07c5\u07c3\3\2\2\2\u07c5")
        buf.write("\u07c4\3\2\2\2\u07c6\u013f\3\2\2\2\u07c7\u07c9\5\u0142")
        buf.write("\u00a2\2\u07c8\u07c7\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca")
        buf.write("\u07c8\3\2\2\2\u07ca\u07cb\3\2\2\2\u07cb\u0141\3\2\2\2")
        buf.write("\u07cc\u07d0\7~\2\2\u07cd\u07ce\5\u0144\u00a3\2\u07ce")
        buf.write("\u07cf\7\u0084\2\2\u07cf\u07d1\3\2\2\2\u07d0\u07cd\3\2")
        buf.write("\2\2\u07d0\u07d1\3\2\2\2\u07d1\u07d2\3\2\2\2\u07d2\u07d4")
        buf.write("\5\u0146\u00a4\2\u07d3\u07d5\7\u0083\2\2\u07d4\u07d3\3")
        buf.write("\2\2\2\u07d4\u07d5\3\2\2\2\u07d5\u07d6\3\2\2\2\u07d6\u07d7")
        buf.write("\7\177\2\2\u07d7\u0143\3\2\2\2\u07d8\u07db\5\u016e\u00b8")
        buf.write("\2\u07d9\u07db\5\u0196\u00cc\2\u07da\u07d8\3\2\2\2\u07da")
        buf.write("\u07d9\3\2\2\2\u07db\u0145\3\2\2\2\u07dc\u07e1\5\u0148")
        buf.write("\u00a5\2\u07dd\u07de\7\u0083\2\2\u07de\u07e0\5\u0148\u00a5")
        buf.write("\2\u07df\u07dd\3\2\2\2\u07e0\u07e3\3\2\2\2\u07e1\u07df")
        buf.write("\3\2\2\2\u07e1\u07e2\3\2\2\2\u07e2\u0147\3\2\2\2\u07e3")
        buf.write("\u07e1\3\2\2\2\u07e4\u07f1\5\4\3\2\u07e5\u07ee\7\u0080")
        buf.write("\2\2\u07e6\u07eb\5\u014a\u00a6\2\u07e7\u07e8\7\u0083\2")
        buf.write("\2\u07e8\u07ea\5\u014a\u00a6\2\u07e9\u07e7\3\2\2\2\u07ea")
        buf.write("\u07ed\3\2\2\2\u07eb\u07e9\3\2\2\2\u07eb\u07ec\3\2\2\2")
        buf.write("\u07ec\u07ef\3\2\2\2\u07ed\u07eb\3\2\2\2\u07ee\u07e6\3")
        buf.write("\2\2\2\u07ee\u07ef\3\2\2\2\u07ef\u07f0\3\2\2\2\u07f0\u07f2")
        buf.write("\7\u0081\2\2\u07f1\u07e5\3\2\2\2\u07f1\u07f2\3\2\2\2\u07f2")
        buf.write("\u0149\3\2\2\2\u07f3\u07f4\5\u0196\u00cc\2\u07f4\u07f5")
        buf.write("\7\u0084\2\2\u07f5\u07f7\3\2\2\2\u07f6\u07f3\3\2\2\2\u07f6")
        buf.write("\u07f7\3\2\2\2\u07f7\u07f8\3\2\2\2\u07f8\u07f9\5\32\16")
        buf.write("\2\u07f9\u014b\3\2\2\2\u07fa\u07fd\5\n\6\2\u07fb\u07fd")
        buf.write("\5\22\n\2\u07fc\u07fa\3\2\2\2\u07fc\u07fb\3\2\2\2\u07fd")
        buf.write("\u0802\3\2\2\2\u07fe\u0801\5\u0124\u0093\2\u07ff\u0801")
        buf.write("\7\u0093\2\2\u0800\u07fe\3\2\2\2\u0800\u07ff\3\2\2\2\u0801")
        buf.write("\u0804\3\2\2\2\u0802\u0800\3\2\2\2\u0802\u0803\3\2\2\2")
        buf.write("\u0803\u0805\3\2\2\2\u0804\u0802\3\2\2\2\u0805\u0806\7")
        buf.write("\u0088\2\2\u0806\u080a\3\2\2\2\u0807\u0808\7l\2\2\u0808")
        buf.write("\u080a\7\u0088\2\2\u0809\u07fc\3\2\2\2\u0809\u0807\3\2")
        buf.write("\2\2\u080a\u014d\3\2\2\2\u080b\u0810\5\u0150\u00a9\2\u080c")
        buf.write("\u080d\7\u0083\2\2\u080d\u080f\5\u0150\u00a9\2\u080e\u080c")
        buf.write("\3\2\2\2\u080f\u0812\3\2\2\2\u0810\u080e\3\2\2\2\u0810")
        buf.write("\u0811\3\2\2\2\u0811\u014f\3\2\2\2\u0812\u0810\3\2\2\2")
        buf.write("\u0813\u0814\5\u0196\u00cc\2\u0814\u0815\7\u0090\2\2\u0815")
        buf.write("\u0816\5\u0152\u00aa\2\u0816\u0151\3\2\2\2\u0817\u0819")
        buf.write("\7\u008b\2\2\u0818\u0817\3\2\2\2\u0818\u0819\3\2\2\2\u0819")
        buf.write("\u081a\3\2\2\2\u081a\u081d\5\32\16\2\u081b\u081d\5\u0156")
        buf.write("\u00ac\2\u081c\u0818\3\2\2\2\u081c\u081b\3\2\2\2\u081d")
        buf.write("\u0153\3\2\2\2\u081e\u081f\5\u0196\u00cc\2\u081f\u0820")
        buf.write("\7~\2\2\u0820\u0821\5\32\16\2\u0821\u0822\7\177\2\2\u0822")
        buf.write("\u0155\3\2\2\2\u0823\u0824\7Z\2\2\u0824\u0825\5\6\4\2")
        buf.write("\u0825\u0826\7~\2\2\u0826\u0827\5\32\16\2\u0827\u0828")
        buf.write("\7\177\2\2\u0828\u0157\3\2\2\2\u0829\u082a\7\u0090\2\2")
        buf.write("\u082a\u082b\7\u0092\2\2\u082b\u082c\6\u00ad\2\3\u082c")
        buf.write("\u0159\3\2\2\2\u082d\u082e\7\u0092\2\2\u082e\u082f\7\u0092")
        buf.write("\2\2\u082f\u0830\6\u00ae\3\3\u0830\u015b\3\2\2\2\u0831")
        buf.write("\u0832\7\u0092\2\2\u0832\u0833\7\u009e\2\2\u0833\u0834")
        buf.write("\6\u00af\4\3\u0834\u015d\3\2\2\2\u0835\u083d\5\u0160\u00b1")
        buf.write("\2\u0836\u083d\5\u0162\u00b2\2\u0837\u083d\7t\2\2\u0838")
        buf.write("\u083d\7u\2\2\u0839\u083d\7v\2\2\u083a\u083d\7w\2\2\u083b")
        buf.write("\u083d\7D\2\2\u083c\u0835\3\2\2\2\u083c\u0836\3\2\2\2")
        buf.write("\u083c\u0837\3\2\2\2\u083c\u0838\3\2\2\2\u083c\u0839\3")
        buf.write("\2\2\2\u083c\u083a\3\2\2\2\u083c\u083b\3\2\2\2\u083d\u015f")
        buf.write("\3\2\2\2\u083e\u083f\t\21\2\2\u083f\u0161\3\2\2\2\u0840")
        buf.write("\u0845\5\u0164\u00b3\2\u0841\u0845\5\u0166\u00b4\2\u0842")
        buf.write("\u0845\7x\2\2\u0843\u0845\7y\2\2\u0844\u0840\3\2\2\2\u0844")
        buf.write("\u0841\3\2\2\2\u0844\u0842\3\2\2\2\u0844\u0843\3\2\2\2")
        buf.write("\u0845\u0163\3\2\2\2\u0846\u084a\7z\2\2\u0847\u0849\5")
        buf.write("\u0168\u00b5\2\u0848\u0847\3\2\2\2\u0849\u084c\3\2\2\2")
        buf.write("\u084a\u0848\3\2\2\2\u084a\u084b\3\2\2\2\u084b\u084d\3")
        buf.write("\2\2\2\u084c\u084a\3\2\2\2\u084d\u084e\7\u00ad\2\2\u084e")
        buf.write("\u0165\3\2\2\2\u084f\u0853\7{\2\2\u0850\u0852\5\u016a")
        buf.write("\u00b6\2\u0851\u0850\3\2\2\2\u0852\u0855\3\2\2\2\u0853")
        buf.write("\u0851\3\2\2\2\u0853\u0854\3\2\2\2\u0854\u0856\3\2\2\2")
        buf.write("\u0855\u0853\3\2\2\2\u0856\u0857\7\u00ad\2\2\u0857\u0167")
        buf.write("\3\2\2\2\u0858\u085d\5\u016c\u00b7\2\u0859\u085d\7\u00a9")
        buf.write("\2\2\u085a\u085d\7\u00ab\2\2\u085b\u085d\7\u00ae\2\2\u085c")
        buf.write("\u0858\3\2\2\2\u085c\u0859\3\2\2\2\u085c\u085a\3\2\2\2")
        buf.write("\u085c\u085b\3\2\2\2\u085d\u0169\3\2\2\2\u085e\u0863\5")
        buf.write("\u016c\u00b7\2\u085f\u0863\7\u00a9\2\2\u0860\u0863\7\u00ac")
        buf.write("\2\2\u0861\u0863\7\u00af\2\2\u0862\u085e\3\2\2\2\u0862")
        buf.write("\u085f\3\2\2\2\u0862\u0860\3\2\2\2\u0862\u0861\3\2\2\2")
        buf.write("\u0863\u016b\3\2\2\2\u0864\u0869\5\32\16\2\u0865\u0866")
        buf.write("\7\u0083\2\2\u0866\u0868\5\32\16\2\u0867\u0865\3\2\2\2")
        buf.write("\u0868\u086b\3\2\2\2\u0869\u0867\3\2\2\2\u0869\u086a\3")
        buf.write("\2\2\2\u086a\u0872\3\2\2\2\u086b\u0869\3\2\2\2\u086c\u086e")
        buf.write("\7\u0084\2\2\u086d\u086f\7\u00b1\2\2\u086e\u086d\3\2\2")
        buf.write("\2\u086f\u0870\3\2\2\2\u0870\u086e\3\2\2\2\u0870\u0871")
        buf.write("\3\2\2\2\u0871\u0873\3\2\2\2\u0872\u086c\3\2\2\2\u0872")
        buf.write("\u0873\3\2\2\2\u0873\u016d\3\2\2\2\u0874\u0875\t\22\2")
        buf.write("\2\u0875\u016f\3\2\2\2\u0876\u0877\7\33\2\2\u0877\u0879")
        buf.write("\5\u0196\u00cc\2\u0878\u087a\5\u00c8e\2\u0879\u0878\3")
        buf.write("\2\2\2\u0879\u087a\3\2\2\2\u087a\u087c\3\2\2\2\u087b\u087d")
        buf.write("\5\u00ccg\2\u087c\u087b\3\2\2\2\u087c\u087d\3\2\2\2\u087d")
        buf.write("\u087f\3\2\2\2\u087e\u0880\5\u00d0i\2\u087f\u087e\3\2")
        buf.write("\2\2\u087f\u0880\3\2\2\2\u0880\u0881\3\2\2\2\u0881\u0883")
        buf.write("\5\u00dco\2\u0882\u0884\7\u0085\2\2\u0883\u0882\3\2\2")
        buf.write("\2\u0883\u0884\3\2\2\2\u0884\u0171\3\2\2\2\u0885\u0886")
        buf.write("\7]\2\2\u0886\u0888\5\u0196\u00cc\2\u0887\u0889\5\u00c8")
        buf.write("e\2\u0888\u0887\3\2\2\2\u0888\u0889\3\2\2\2\u0889\u088b")
        buf.write("\3\2\2\2\u088a\u088c\5\u011c\u008f\2\u088b\u088a\3\2\2")
        buf.write("\2\u088b\u088c\3\2\2\2\u088c\u088e\3\2\2\2\u088d\u088f")
        buf.write("\5\u00d0i\2\u088e\u088d\3\2\2\2\u088e\u088f\3\2\2\2\u088f")
        buf.write("\u0890\3\2\2\2\u0890\u0892\5\u011e\u0090\2\u0891\u0893")
        buf.write("\7\u0085\2\2\u0892\u0891\3\2\2\2\u0892\u0893\3\2\2\2\u0893")
        buf.write("\u0173\3\2\2\2\u0894\u0895\79\2\2\u0895\u0897\5\u0196")
        buf.write("\u00cc\2\u0896\u0898\5\u0128\u0095\2\u0897\u0896\3\2\2")
        buf.write("\2\u0897\u0898\3\2\2\2\u0898\u089a\3\2\2\2\u0899\u089b")
        buf.write("\5\u012e\u0098\2\u089a\u0899\3\2\2\2\u089a\u089b\3\2\2")
        buf.write("\2\u089b\u089d\3\2\2\2\u089c\u089e\5\u00d0i\2\u089d\u089c")
        buf.write("\3\2\2\2\u089d\u089e\3\2\2\2\u089e\u089f\3\2\2\2\u089f")
        buf.write("\u08a1\5\u0130\u0099\2\u08a0\u08a2\7\u0085\2\2\u08a1\u08a0")
        buf.write("\3\2\2\2\u08a1\u08a2\3\2\2\2\u08a2\u0175\3\2\2\2\u08a3")
        buf.write("\u08a4\7&\2\2\u08a4\u08a6\5\u0196\u00cc\2\u08a5\u08a7")
        buf.write("\5\u0136\u009c\2\u08a6\u08a5\3\2\2\2\u08a6\u08a7\3\2\2")
        buf.write("\2\u08a7\u08a8\3\2\2\2\u08a8\u08aa\5\u0138\u009d\2\u08a9")
        buf.write("\u08ab\7\u0085\2\2\u08aa\u08a9\3\2\2\2\u08aa\u08ab\3\2")
        buf.write("\2\2\u08ab\u0177\3\2\2\2\u08ac\u08ad\7 \2\2\u08ad\u08ae")
        buf.write("\5\u00f4{\2\u08ae\u08b0\5\u0196\u00cc\2\u08af\u08b1\5")
        buf.write("\u0128\u0095\2\u08b0\u08af\3\2\2\2\u08b0\u08b1\3\2\2\2")
        buf.write("\u08b1\u08b2\3\2\2\2\u08b2\u08b4\7\u0080\2\2\u08b3\u08b5")
        buf.write("\5\u00fa~\2\u08b4\u08b3\3\2\2\2\u08b4\u08b5\3\2\2\2\u08b5")
        buf.write("\u08b6\3\2\2\2\u08b6\u08b8\7\u0081\2\2\u08b7\u08b9\5\u00d0")
        buf.write("i\2\u08b8\u08b7\3\2\2\2\u08b8\u08b9\3\2\2\2\u08b9\u08ba")
        buf.write("\3\2\2\2\u08ba\u08bb\7\u0085\2\2\u08bb\u0179\3\2\2\2\u08bc")
        buf.write("\u08bd\7(\2\2\u08bd\u08c6\5\6\4\2\u08be\u08bf\5\u00ee")
        buf.write("x\2\u08bf\u08c0\7\u0085\2\2\u08c0\u08c7\3\2\2\2\u08c1")
        buf.write("\u08c2\5\u00f6|\2\u08c2\u08c3\7|\2\2\u08c3\u08c4\5\u010e")
        buf.write("\u0088\2\u08c4\u08c5\7}\2\2\u08c5\u08c7\3\2\2\2\u08c6")
        buf.write("\u08be\3\2\2\2\u08c6\u08c1\3\2\2\2\u08c7\u017b\3\2\2\2")
        buf.write("\u08c8\u08c9\5\u00eex\2\u08c9\u08ca\7\u0085\2\2\u08ca")
        buf.write("\u017d\3\2\2\2\u08cb\u08d9\5\u00f6|\2\u08cc\u08cd\7|\2")
        buf.write("\2\u08cd\u08ce\5\u0104\u0083\2\u08ce\u08d3\7}\2\2\u08cf")
        buf.write("\u08d0\7\u0090\2\2\u08d0\u08d1\5\u00f2z\2\u08d1\u08d2")
        buf.write("\7\u0085\2\2\u08d2\u08d4\3\2\2\2\u08d3\u08cf\3\2\2\2\u08d3")
        buf.write("\u08d4\3\2\2\2\u08d4\u08da\3\2\2\2\u08d5\u08d6\5\u0158")
        buf.write("\u00ad\2\u08d6\u08d7\5\32\16\2\u08d7\u08d8\7\u0085\2\2")
        buf.write("\u08d8\u08da\3\2\2\2\u08d9\u08cc\3\2\2\2\u08d9\u08d5\3")
        buf.write("\2\2\2\u08da\u017f\3\2\2\2\u08db\u08dc\7\34\2\2\u08dc")
        buf.write("\u08dd\5\6\4\2\u08dd\u08de\5\u00eav\2\u08de\u08df\7\u0085")
        buf.write("\2\2\u08df\u0181\3\2\2\2\u08e0\u08e1\7_\2\2\u08e1\u08e2")
        buf.write("\7~\2\2\u08e2\u08e3\5\u00fa~\2\u08e3\u08ec\7\177\2\2\u08e4")
        buf.write("\u08e5\7|\2\2\u08e5\u08e6\5\u0104\u0083\2\u08e6\u08e7")
        buf.write("\7}\2\2\u08e7\u08ed\3\2\2\2\u08e8\u08e9\5\u0158\u00ad")
        buf.write("\2\u08e9\u08ea\5\32\16\2\u08ea\u08eb\7\u0085\2\2\u08eb")
        buf.write("\u08ed\3\2\2\2\u08ec\u08e4\3\2\2\2\u08ec\u08e8\3\2\2\2")
        buf.write("\u08ed\u0183\3\2\2\2\u08ee\u08ef\7\u008f\2\2\u08ef\u08f0")
        buf.write("\5\u0196\u00cc\2\u08f0\u08f1\7\u0080\2\2\u08f1\u08f2\7")
        buf.write("\u0081\2\2\u08f2\u08f3\5\u011a\u008e\2\u08f3\u0185\3\2")
        buf.write("\2\2\u08f4\u08f5\5\u0196\u00cc\2\u08f5\u08f7\7\u0080\2")
        buf.write("\2\u08f6\u08f8\5\u00fa~\2\u08f7\u08f6\3\2\2\2\u08f7\u08f8")
        buf.write("\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9\u08fb\7\u0081\2\2\u08fa")
        buf.write("\u08fc\5\u0118\u008d\2\u08fb\u08fa\3\2\2\2\u08fb\u08fc")
        buf.write("\3\2\2\2\u08fc\u08fd\3\2\2\2\u08fd\u08fe\5\u011a\u008e")
        buf.write("\2\u08fe\u0187\3\2\2\2\u08ff\u0901\5\u018a\u00c6\2\u0900")
        buf.write("\u0902\5\u00c8e\2\u0901\u0900\3\2\2\2\u0901\u0902\3\2")
        buf.write("\2\2\u0902\u0903\3\2\2\2\u0903\u0905\7\u0080\2\2\u0904")
        buf.write("\u0906\5\u00fa~\2\u0905\u0904\3\2\2\2\u0905\u0906\3\2")
        buf.write("\2\2\u0906\u0907\3\2\2\2\u0907\u0909\7\u0081\2\2\u0908")
        buf.write("\u090a\5\u00d0i\2\u0909\u0908\3\2\2\2\u0909\u090a\3\2")
        buf.write("\2\2\u090a\u0910\3\2\2\2\u090b\u0911\5\u00f8}\2\u090c")
        buf.write("\u090d\5\u0158\u00ad\2\u090d\u090e\5\32\16\2\u090e\u090f")
        buf.write("\7\u0085\2\2\u090f\u0911\3\2\2\2\u0910\u090b\3\2\2\2\u0910")
        buf.write("\u090c\3\2\2\2\u0911\u0189\3\2\2\2\u0912\u0918\5\u0196")
        buf.write("\u00cc\2\u0913\u0914\5\u0196\u00cc\2\u0914\u0915\7\u0094")
        buf.write("\2\2\u0915\u0916\5\u0196\u00cc\2\u0916\u0918\3\2\2\2\u0917")
        buf.write("\u0912\3\2\2\2\u0917\u0913\3\2\2\2\u0918\u0920\3\2\2\2")
        buf.write("\u0919\u091b\5\24\13\2\u091a\u0919\3\2\2\2\u091a\u091b")
        buf.write("\3\2\2\2\u091b\u091c\3\2\2\2\u091c\u091d\7\u0082\2\2\u091d")
        buf.write("\u091f\5\u0196\u00cc\2\u091e\u091a\3\2\2\2\u091f\u0922")
        buf.write("\3\2\2\2\u0920\u091e\3\2\2\2\u0920\u0921\3\2\2\2\u0921")
        buf.write("\u018b\3\2\2\2\u0922\u0920\3\2\2\2\u0923\u0924\7G\2\2")
        buf.write("\u0924\u0925\5\u0114\u008b\2\u0925\u0926\7\u0080\2\2\u0926")
        buf.write("\u0929\5\u018e\u00c8\2\u0927\u0928\7\u0083\2\2\u0928\u092a")
        buf.write("\5\u018e\u00c8\2\u0929\u0927\3\2\2\2\u0929\u092a\3\2\2")
        buf.write("\2\u092a\u092b\3\2\2\2\u092b\u0931\7\u0081\2\2\u092c\u0932")
        buf.write("\5\u011a\u008e\2\u092d\u092e\5\u0158\u00ad\2\u092e\u092f")
        buf.write("\5\32\16\2\u092f\u0930\7\u0085\2\2\u0930\u0932\3\2\2\2")
        buf.write("\u0931\u092c\3\2\2\2\u0931\u092d\3\2\2\2\u0932\u018d\3")
        buf.write("\2\2\2\u0933\u0934\5\6\4\2\u0934\u0937\5\u0196\u00cc\2")
        buf.write("\u0935\u0936\7\u0090\2\2\u0936\u0938\5\32\16\2\u0937\u0935")
        buf.write("\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u018f\3\2\2\2\u0939")
        buf.write("\u093b\7\u0080\2\2\u093a\u093c\5\26\f\2\u093b\u093a\3")
        buf.write("\2\2\2\u093b\u093c\3\2\2\2\u093c\u093d\3\2\2\2\u093d\u093e")
        buf.write("\7\u0081\2\2\u093e\u0191\3\2\2\2\u093f\u0941\7\u0080\2")
        buf.write("\2\u0940\u0942\5\26\f\2\u0941\u0940\3\2\2\2\u0941\u0942")
        buf.write("\3\2\2\2\u0942\u0943\3\2\2\2\u0943\u0945\7\u0081\2\2\u0944")
        buf.write("\u0946\5J&\2\u0945\u0944\3\2\2\2\u0945\u0946\3\2\2\2\u0946")
        buf.write("\u0193\3\2\2\2\u0947\u0948\t\23\2\2\u0948\u0195\3\2\2")
        buf.write("\2\u0949\u094a\t\24\2\2\u094a\u0197\3\2\2\2\u012d\u0199")
        buf.write("\u019c\u019f\u01a4\u01a8\u01ae\u01b1\u01b6\u01ba\u01c1")
        buf.write("\u01c3\u01ca\u01ce\u01d3\u01dd\u01e5\u01ef\u01f5\u01f8")
        buf.write("\u01fc\u0202\u0207\u0218\u0220\u0225\u022c\u0234\u023c")
        buf.write("\u0244\u024c\u0254\u025e\u0260\u0266\u026b\u0273\u027b")
        buf.write("\u0296\u029c\u02a5\u02aa\u02af\u02b5\u02c3\u02c9\u02d5")
        buf.write("\u02d9\u02de\u02e2\u02e8\u02ef\u0302\u0307\u030a\u0319")
        buf.write("\u031f\u0322\u0327\u032a\u0332\u033a\u0345\u034a\u034f")
        buf.write("\u0351\u035a\u0362\u0369\u0371\u0375\u037e\u0383\u0385")
        buf.write("\u038e\u0396\u039a\u039f\u03a1\u03a6\u03aa\u03b1\u03b9")
        buf.write("\u03bb\u03bf\u03c2\u03d3\u03da\u03de\u03e8\u03ed\u03f4")
        buf.write("\u03fd\u0402\u0409\u0415\u0420\u0428\u042d\u0436\u043f")
        buf.write("\u0444\u044c\u0459\u0463\u0479\u047d\u0481\u0497\u049c")
        buf.write("\u04a1\u04a8\u04ab\u04c1\u04cd\u04d1\u04db\u04e0\u04e5")
        buf.write("\u04ea\u04f2\u04f7\u0501\u0506\u050e\u0511\u0518\u051f")
        buf.write("\u0523\u0526\u052c\u0530\u0536\u0544\u054a\u0551\u0556")
        buf.write("\u0559\u055c\u0563\u056d\u057e\u0583\u0588\u058b\u058e")
        buf.write("\u0595\u059b\u05a3\u05a9\u05b3\u05bb\u05c1\u05cc\u05d0")
        buf.write("\u05d2\u05d7\u05de\u05e7\u05ee\u05f2\u05f5\u05f9\u05fb")
        buf.write("\u0600\u060d\u0617\u0623\u062a\u0636\u063c\u0640\u0644")
        buf.write("\u064a\u0650\u0652\u0659\u065d\u0660\u0664\u0669\u0670")
        buf.write("\u0673\u0678\u067d\u067f\u0682\u0685\u068b\u068e\u069a")
        buf.write("\u069e\u06a1\u06ab\u06ae\u06b4\u06cf\u06dc\u06e2\u06eb")
        buf.write("\u06f1\u06f4\u06fc\u0700\u0706\u070c\u0712\u071d\u0721")
        buf.write("\u0723\u072d\u0733\u0736\u0743\u0749\u074c\u074f\u0754")
        buf.write("\u0758\u075c\u076d\u0770\u0775\u0779\u077d\u0786\u0789")
        buf.write("\u078e\u0792\u0797\u079b\u079d\u07a8\u07ac\u07ae\u07b3")
        buf.write("\u07b8\u07bf\u07c5\u07ca\u07d0\u07d4\u07da\u07e1\u07eb")
        buf.write("\u07ee\u07f1\u07f6\u07fc\u0800\u0802\u0809\u0810\u0818")
        buf.write("\u081c\u083c\u0844\u084a\u0853\u085c\u0862\u0869\u0870")
        buf.write("\u0872\u0879\u087c\u087f\u0883\u0888\u088b\u088e\u0892")
        buf.write("\u0897\u089a\u089d\u08a1\u08a6\u08aa\u08b0\u08b4\u08b8")
        buf.write("\u08c6\u08d3\u08d9\u08ec\u08f7\u08fb\u0901\u0905\u0909")
        buf.write("\u0910\u0917\u091a\u0920\u0929\u0931\u0937\u093b\u0941")
        buf.write("\u0945")
        return buf.getvalue()


class CSharpParser ( Parser ):

    grammarFileName = "CSharpParser.g4"

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

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

    sharedContextCache = PredictionContextCache()

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

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

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

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

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

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




    class Compilation_unitContext(ParserRuleContext):

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

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

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

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


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


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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_compilation_unit

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

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




    def compilation_unit(self):

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


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


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


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

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


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


    class Namespace_or_type_nameContext(ParserRuleContext):

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

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


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


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_or_type_name

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

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




    def namespace_or_type_name(self):

        localctx = CSharpParser.Namespace_or_type_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_namespace_or_type_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 431
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.state = 426
                self.identifier()
                self.state = 428
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
                if la_ == 1:
                    self.state = 427
                    self.type_argument_list()


                pass

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


            self.state = 440
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 433
                    self.match(CSharpParser.DOT)
                    self.state = 434
                    self.identifier()
                    self.state = 436
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
                    if la_ == 1:
                        self.state = 435
                        self.type_argument_list()

             
                self.state = 442
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

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


    class CstypeContext(ParserRuleContext):

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

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


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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_cstype

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

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




    def cstype(self):

        localctx = CSharpParser.CstypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_cstype)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 443
            self.base_type()
            self.state = 449
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 447
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.INTERR]:
                        self.state = 444
                        self.match(CSharpParser.INTERR)
                        pass
                    elif token in [CSharpParser.OPEN_BRACKET]:
                        self.state = 445
                        self.rank_specifier()
                        pass
                    elif token in [CSharpParser.STAR]:
                        self.state = 446
                        self.match(CSharpParser.STAR)
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 451
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

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


    class Base_typeContext(ParserRuleContext):

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

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


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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_base_type

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

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




    def base_type(self):

        localctx = CSharpParser.Base_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_base_type)
        try:
            self.state = 456
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.BOOL, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 452
                self.simple_type()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 453
                self.class_type()
                pass
            elif token in [CSharpParser.VOID]:
                self.enterOuterAlt(localctx, 3)
                self.state = 454
                self.match(CSharpParser.VOID)
                self.state = 455
                self.match(CSharpParser.STAR)
                pass
            else:
                raise NoViableAltException(self)

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


    class Simple_typeContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_simple_type

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

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




    def simple_type(self):

        localctx = CSharpParser.Simple_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_simple_type)
        try:
            self.state = 460
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 458
                self.numeric_type()
                pass
            elif token in [CSharpParser.BOOL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 459
                self.match(CSharpParser.BOOL)
                pass
            else:
                raise NoViableAltException(self)

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


    class Numeric_typeContext(ParserRuleContext):

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

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


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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_numeric_type

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

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




    def numeric_type(self):

        localctx = CSharpParser.Numeric_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_numeric_type)
        try:
            self.state = 465
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 462
                self.integral_type()
                pass
            elif token in [CSharpParser.DOUBLE, CSharpParser.FLOAT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 463
                self.floating_point_type()
                pass
            elif token in [CSharpParser.DECIMAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 464
                self.match(CSharpParser.DECIMAL)
                pass
            else:
                raise NoViableAltException(self)

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


    class Integral_typeContext(ParserRuleContext):

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_integral_type

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

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




    def integral_type(self):

        localctx = CSharpParser.Integral_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_integral_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 467
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.INT) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 82)) & ~0x3f) == 0 and ((1 << (_la - 82)) & ((1 << (CSharpParser.SBYTE - 82)) | (1 << (CSharpParser.SHORT - 82)) | (1 << (CSharpParser.UINT - 82)) | (1 << (CSharpParser.ULONG - 82)) | (1 << (CSharpParser.USHORT - 82)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Floating_point_typeContext(ParserRuleContext):

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_floating_point_type

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

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




    def floating_point_type(self):

        localctx = CSharpParser.Floating_point_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_floating_point_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            _la = self._input.LA(1)
            if not(_la==CSharpParser.DOUBLE or _la==CSharpParser.FLOAT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_typeContext(ParserRuleContext):

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

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


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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_class_type

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

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




    def class_type(self):

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

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

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

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 474
                self.match(CSharpParser.STRING)
                pass


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


    class Type_argument_listContext(ParserRuleContext):

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

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

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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_type_argument_list

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

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




    def type_argument_list(self):

        localctx = CSharpParser.Type_argument_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_type_argument_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 477
            self.match(CSharpParser.LT)
            self.state = 478
            self.cstype()
            self.state = 483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 479
                self.match(CSharpParser.COMMA)
                self.state = 480
                self.cstype()
                self.state = 485
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Argument_listContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_argument_list

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

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




    def argument_list(self):

        localctx = CSharpParser.Argument_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_argument_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 488
            self.argument()
            self.state = 493
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 489
                self.match(CSharpParser.COMMA)
                self.state = 490
                self.argument()
                self.state = 495
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class ArgumentContext(ParserRuleContext):

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

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


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


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

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_argument

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

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




    def argument(self):

        localctx = CSharpParser.ArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_argument)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 499
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.state = 496
                self.identifier()
                self.state = 497
                self.match(CSharpParser.COLON)


            self.state = 502
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OUT or _la==CSharpParser.REF:
                self.state = 501
                localctx.refout = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==CSharpParser.OUT or _la==CSharpParser.REF):
                    localctx.refout = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                self.state = 504
                self.match(CSharpParser.VAR)

            elif la_ == 2:
                self.state = 505
                self.cstype()


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


    class ExpressionContext(ParserRuleContext):

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

        def assignment(self):
            return self.getTypedRuleContext(CSharpParser.AssignmentContext,0)


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


        def getRuleIndex(self):
            return CSharpParser.RULE_expression

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

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




    def expression(self):

        localctx = CSharpParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_expression)
        try:
            self.state = 512
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 510
                self.assignment()
                pass

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


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


    class Non_assignment_expressionContext(ParserRuleContext):

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

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


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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_non_assignment_expression

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

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




    def non_assignment_expression(self):

        localctx = CSharpParser.Non_assignment_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_non_assignment_expression)
        try:
            self.state = 517
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 514
                self.lambda_expression()
                pass

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

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 516
                self.conditional_expression()
                pass


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


    class AssignmentContext(ParserRuleContext):

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

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


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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_assignment

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

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




    def assignment(self):

        localctx = CSharpParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 519
            self.unary_expression()
            self.state = 520
            self.assignment_operator()
            self.state = 521
            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):

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

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

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

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

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

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

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

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

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

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

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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_assignment_operator

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

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




    def assignment_operator(self):

        localctx = CSharpParser.Assignment_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_assignment_operator)
        try:
            self.state = 534
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ASSIGNMENT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 523
                self.match(CSharpParser.ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_ADD_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 524
                self.match(CSharpParser.OP_ADD_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_SUB_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 525
                self.match(CSharpParser.OP_SUB_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_MULT_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 526
                self.match(CSharpParser.OP_MULT_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_DIV_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 527
                self.match(CSharpParser.OP_DIV_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_MOD_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 6)
                self.state = 528
                self.match(CSharpParser.OP_MOD_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_AND_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 7)
                self.state = 529
                self.match(CSharpParser.OP_AND_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_OR_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 8)
                self.state = 530
                self.match(CSharpParser.OP_OR_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_XOR_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 9)
                self.state = 531
                self.match(CSharpParser.OP_XOR_ASSIGNMENT)
                pass
            elif token in [CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT]:
                self.enterOuterAlt(localctx, 10)
                self.state = 532
                self.match(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT)
                pass
            elif token in [CSharpParser.GT]:
                self.enterOuterAlt(localctx, 11)
                self.state = 533
                self.right_shift_assignment()
                pass
            else:
                raise NoViableAltException(self)

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


    class Conditional_expressionContext(ParserRuleContext):

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

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


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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_conditional_expression

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

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




    def conditional_expression(self):

        localctx = CSharpParser.Conditional_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_conditional_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 536
            self.null_coalescing_expression()
            self.state = 542
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.INTERR:
                self.state = 537
                self.match(CSharpParser.INTERR)
                self.state = 538
                self.expression()
                self.state = 539
                self.match(CSharpParser.COLON)
                self.state = 540
                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 Null_coalescing_expressionContext(ParserRuleContext):

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

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


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_null_coalescing_expression

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

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




    def null_coalescing_expression(self):

        localctx = CSharpParser.Null_coalescing_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_null_coalescing_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 544
            self.conditional_or_expression()
            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OP_COALESCING:
                self.state = 545
                self.match(CSharpParser.OP_COALESCING)
                self.state = 546
                self.null_coalescing_expression()


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


    class Conditional_or_expressionContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_conditional_or_expression

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

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




    def conditional_or_expression(self):

        localctx = CSharpParser.Conditional_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_conditional_or_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 549
            self.conditional_and_expression()
            self.state = 554
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.OP_OR:
                self.state = 550
                self.match(CSharpParser.OP_OR)
                self.state = 551
                self.conditional_and_expression()
                self.state = 556
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Conditional_and_expressionContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_conditional_and_expression

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

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




    def conditional_and_expression(self):

        localctx = CSharpParser.Conditional_and_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_conditional_and_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 557
            self.inclusive_or_expression()
            self.state = 562
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.OP_AND:
                self.state = 558
                self.match(CSharpParser.OP_AND)
                self.state = 559
                self.inclusive_or_expression()
                self.state = 564
                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 Inclusive_or_expressionContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_inclusive_or_expression

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

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




    def inclusive_or_expression(self):

        localctx = CSharpParser.Inclusive_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_inclusive_or_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 565
            self.exclusive_or_expression()
            self.state = 570
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.BITWISE_OR:
                self.state = 566
                self.match(CSharpParser.BITWISE_OR)
                self.state = 567
                self.exclusive_or_expression()
                self.state = 572
                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 Exclusive_or_expressionContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_exclusive_or_expression

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

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




    def exclusive_or_expression(self):

        localctx = CSharpParser.Exclusive_or_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_exclusive_or_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 573
            self.and_expression()
            self.state = 578
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.CARET:
                self.state = 574
                self.match(CSharpParser.CARET)
                self.state = 575
                self.and_expression()
                self.state = 580
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class And_expressionContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_and_expression

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

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




    def and_expression(self):

        localctx = CSharpParser.And_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_and_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 581
            self.equality_expression()
            self.state = 586
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 582
                    self.match(CSharpParser.AMP)
                    self.state = 583
                    self.equality_expression() 
                self.state = 588
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,29,self._ctx)

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


    class Equality_expressionContext(ParserRuleContext):

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

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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_equality_expression

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

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




    def equality_expression(self):

        localctx = CSharpParser.Equality_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_equality_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 589
            self.relational_expression()
            self.state = 594
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.OP_EQ or _la==CSharpParser.OP_NE:
                self.state = 590
                _la = self._input.LA(1)
                if not(_la==CSharpParser.OP_EQ or _la==CSharpParser.OP_NE):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 591
                self.relational_expression()
                self.state = 596
                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):

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

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


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

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


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

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


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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_relational_expression

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

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




    def relational_expression(self):

        localctx = CSharpParser.Relational_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_relational_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 597
            self.shift_expression()
            self.state = 606
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.AS or _la==CSharpParser.IS or ((((_la - 143)) & ~0x3f) == 0 and ((1 << (_la - 143)) & ((1 << (CSharpParser.LT - 143)) | (1 << (CSharpParser.GT - 143)) | (1 << (CSharpParser.OP_LE - 143)) | (1 << (CSharpParser.OP_GE - 143)))) != 0):
                self.state = 604
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.LT, CSharpParser.GT, CSharpParser.OP_LE, CSharpParser.OP_GE]:
                    self.state = 598
                    _la = self._input.LA(1)
                    if not(((((_la - 143)) & ~0x3f) == 0 and ((1 << (_la - 143)) & ((1 << (CSharpParser.LT - 143)) | (1 << (CSharpParser.GT - 143)) | (1 << (CSharpParser.OP_LE - 143)) | (1 << (CSharpParser.OP_GE - 143)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 599
                    self.shift_expression()
                    pass
                elif token in [CSharpParser.IS]:
                    self.state = 600
                    self.match(CSharpParser.IS)
                    self.state = 601
                    self.isType()
                    pass
                elif token in [CSharpParser.AS]:
                    self.state = 602
                    self.match(CSharpParser.AS)
                    self.state = 603
                    self.cstype()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 608
                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):

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

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


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_shift_expression

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

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




    def shift_expression(self):

        localctx = CSharpParser.Shift_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_shift_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 609
            self.additive_expression()
            self.state = 617
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 612
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.OP_LEFT_SHIFT]:
                        self.state = 610
                        self.match(CSharpParser.OP_LEFT_SHIFT)
                        pass
                    elif token in [CSharpParser.GT]:
                        self.state = 611
                        self.right_shift()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 614
                    self.additive_expression() 
                self.state = 619
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

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


    class Additive_expressionContext(ParserRuleContext):

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

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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_additive_expression

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

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




    def additive_expression(self):

        localctx = CSharpParser.Additive_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_additive_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 620
            self.multiplicative_expression()
            self.state = 625
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 621
                    _la = self._input.LA(1)
                    if not(_la==CSharpParser.PLUS or _la==CSharpParser.MINUS):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 622
                    self.multiplicative_expression() 
                self.state = 627
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,35,self._ctx)

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


    class Multiplicative_expressionContext(ParserRuleContext):

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

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


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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_multiplicative_expression

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

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




    def multiplicative_expression(self):

        localctx = CSharpParser.Multiplicative_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_multiplicative_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 628
            self.unary_expression()
            self.state = 633
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,36,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 629
                    _la = self._input.LA(1)
                    if not(((((_la - 134)) & ~0x3f) == 0 and ((1 << (_la - 134)) & ((1 << (CSharpParser.STAR - 134)) | (1 << (CSharpParser.DIV - 134)) | (1 << (CSharpParser.PERCENT - 134)))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 630
                    self.unary_expression() 
                self.state = 635
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

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


    class Unary_expressionContext(ParserRuleContext):

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

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


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

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


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

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

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

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

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

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_unary_expression

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

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




    def unary_expression(self):

        localctx = CSharpParser.Unary_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_unary_expression)
        try:
            self.state = 660
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 636
                self.primary_expression()
                pass

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

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

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

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

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

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

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 649
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 650
                self.cstype()
                self.state = 651
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 652
                self.unary_expression()
                pass

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

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

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


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


    class Primary_expressionContext(ParserRuleContext):

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

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


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


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


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


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

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

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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_primary_expression

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

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




    def primary_expression(self):

        localctx = CSharpParser.Primary_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_primary_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 662
            localctx.pe = self.primary_expression_start()
            self.state = 666
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,38,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 663
                    self.bracket_expression() 
                self.state = 668
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,38,self._ctx)

            self.state = 685
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 675
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.DOT, CSharpParser.INTERR]:
                        self.state = 669
                        self.member_access()
                        pass
                    elif token in [CSharpParser.OPEN_PARENS]:
                        self.state = 670
                        self.method_invocation()
                        pass
                    elif token in [CSharpParser.OP_INC]:
                        self.state = 671
                        self.match(CSharpParser.OP_INC)
                        pass
                    elif token in [CSharpParser.OP_DEC]:
                        self.state = 672
                        self.match(CSharpParser.OP_DEC)
                        pass
                    elif token in [CSharpParser.OP_PTR]:
                        self.state = 673
                        self.match(CSharpParser.OP_PTR)
                        self.state = 674
                        self.identifier()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 680
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 677
                            self.bracket_expression() 
                        self.state = 682
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
             
                self.state = 687
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

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


    class Primary_expression_startContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return CSharpParser.RULE_primary_expression_start

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



    class LiteralAccessExpressionContext(Primary_expression_startContext):

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

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

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

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


    class DefaultValueExpressionContext(Primary_expression_startContext):

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

        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)

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

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

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


    class BaseAccessExpressionContext(Primary_expression_startContext):

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

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

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

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


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

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


    class SizeofExpressionContext(Primary_expression_startContext):

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

        def SIZEOF(self):
            return self.getToken(CSharpParser.SIZEOF, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)

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

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

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


    class ParenthesisExpressionsContext(Primary_expression_startContext):

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

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

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

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

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


    class ThisReferenceExpressionContext(Primary_expression_startContext):

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

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

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

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


    class ObjectCreationExpressionContext(Primary_expression_startContext):

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

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)
        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)

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

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

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

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

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

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

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

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

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


    class AnonymousMethodExpressionContext(Primary_expression_startContext):

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

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

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


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

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


    class TypeofExpressionContext(Primary_expression_startContext):

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

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)

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

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

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


    class UncheckedExpressionContext(Primary_expression_startContext):

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

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

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

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

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


    class SimpleNameExpressionContext(Primary_expression_startContext):

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

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

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


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

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


    class MemberAccessExpressionContext(Primary_expression_startContext):

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

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

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


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

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


    class CheckedExpressionContext(Primary_expression_startContext):

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

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

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

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

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


    class LiteralExpressionContext(Primary_expression_startContext):

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

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


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

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


    class NameofExpressionContext(Primary_expression_startContext):

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

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

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

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

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



    def primary_expression_start(self):

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

            elif la_ == 2:
                localctx = CSharpParser.SimpleNameExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 689
                self.identifier()
                self.state = 691
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
                if la_ == 1:
                    self.state = 690
                    self.type_argument_list()


                pass

            elif la_ == 3:
                localctx = CSharpParser.ParenthesisExpressionsContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 693
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 694
                self.expression()
                self.state = 695
                self.match(CSharpParser.CLOSE_PARENS)
                pass

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

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

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

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

            elif la_ == 8:
                localctx = CSharpParser.BaseAccessExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 701
                self.match(CSharpParser.BASE)
                self.state = 711
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.DOT]:
                    self.state = 702
                    self.match(CSharpParser.DOT)
                    self.state = 703
                    self.identifier()
                    self.state = 705
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                    if la_ == 1:
                        self.state = 704
                        self.type_argument_list()


                    pass
                elif token in [CSharpParser.OPEN_BRACKET]:
                    self.state = 707
                    self.match(CSharpParser.OPEN_BRACKET)
                    self.state = 708
                    self.expression_list()
                    self.state = 709
                    self.match(CSharpParser.CLOSE_BRACKET)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

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

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

                    elif la_ == 3:
                        self.state = 717
                        self.match(CSharpParser.OPEN_BRACKET)
                        self.state = 718
                        self.expression_list()
                        self.state = 719
                        self.match(CSharpParser.CLOSE_BRACKET)
                        self.state = 723
                        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 = 720
                                self.rank_specifier() 
                            self.state = 725
                            self._errHandler.sync(self)
                            _alt = self._interp.adaptivePredict(self._input,45,self._ctx)

                        self.state = 727
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==CSharpParser.OPEN_BRACE:
                            self.state = 726
                            self.array_initializer()


                        pass

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

                        self.state = 734
                        self.array_initializer()
                        pass


                    pass
                elif token in [CSharpParser.OPEN_BRACE]:
                    self.state = 738
                    self.anonymous_object_initializer()
                    pass
                elif token in [CSharpParser.OPEN_BRACKET]:
                    self.state = 739
                    self.rank_specifier()
                    self.state = 740
                    self.array_initializer()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 10:
                localctx = CSharpParser.TypeofExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 744
                self.match(CSharpParser.TYPEOF)
                self.state = 745
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 749
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
                if la_ == 1:
                    self.state = 746
                    self.unbound_type_name()
                    pass

                elif la_ == 2:
                    self.state = 747
                    self.cstype()
                    pass

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


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

            elif la_ == 11:
                localctx = CSharpParser.CheckedExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 752
                self.match(CSharpParser.CHECKED)
                self.state = 753
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 754
                self.expression()
                self.state = 755
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 12:
                localctx = CSharpParser.UncheckedExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 12)
                self.state = 757
                self.match(CSharpParser.UNCHECKED)
                self.state = 758
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 759
                self.expression()
                self.state = 760
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 13:
                localctx = CSharpParser.DefaultValueExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 13)
                self.state = 762
                self.match(CSharpParser.DEFAULT)
                self.state = 763
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 764
                self.cstype()
                self.state = 765
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 14:
                localctx = CSharpParser.AnonymousMethodExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 768
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.ASYNC:
                    self.state = 767
                    self.match(CSharpParser.ASYNC)


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


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


                self.state = 778
                self.block()
                pass

            elif la_ == 15:
                localctx = CSharpParser.SizeofExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 779
                self.match(CSharpParser.SIZEOF)
                self.state = 780
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 781
                self.cstype()
                self.state = 782
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 16:
                localctx = CSharpParser.NameofExpressionContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 784
                self.match(CSharpParser.NAMEOF)
                self.state = 785
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 791
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,54,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 786
                        self.identifier()
                        self.state = 787
                        self.match(CSharpParser.DOT) 
                    self.state = 793
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,54,self._ctx)

                self.state = 794
                self.identifier()
                self.state = 795
                self.match(CSharpParser.CLOSE_PARENS)
                pass


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


    class Member_accessContext(ParserRuleContext):

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

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

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


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_member_access

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

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




    def member_access(self):

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


            self.state = 802
            self.match(CSharpParser.DOT)
            self.state = 803
            self.identifier()
            self.state = 805
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 804
                self.type_argument_list()


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


    class Bracket_expressionContext(ParserRuleContext):

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

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

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


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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_bracket_expression

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

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




    def bracket_expression(self):

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


            self.state = 810
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 811
            self.indexer_argument()
            self.state = 816
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 812
                self.match(CSharpParser.COMMA)
                self.state = 813
                self.indexer_argument()
                self.state = 818
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Indexer_argumentContext(ParserRuleContext):

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

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


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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_indexer_argument

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

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




    def indexer_argument(self):

        localctx = CSharpParser.Indexer_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_indexer_argument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 824
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                self.state = 821
                self.identifier()
                self.state = 822
                self.match(CSharpParser.COLON)


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


    class Predefined_typeContext(ParserRuleContext):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_predefined_type

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

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




    def predefined_type(self):

        localctx = CSharpParser.Predefined_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_predefined_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 828
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.BOOL) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.INT) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CSharpParser.OBJECT - 67)) | (1 << (CSharpParser.SBYTE - 67)) | (1 << (CSharpParser.SHORT - 67)) | (1 << (CSharpParser.STRING - 67)) | (1 << (CSharpParser.UINT - 67)) | (1 << (CSharpParser.ULONG - 67)) | (1 << (CSharpParser.USHORT - 67)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Expression_listContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_expression_list

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

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




    def expression_list(self):

        localctx = CSharpParser.Expression_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_expression_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 830
            self.expression()
            self.state = 835
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 831
                self.match(CSharpParser.COMMA)
                self.state = 832
                self.expression()
                self.state = 837
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Object_or_collection_initializerContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_object_or_collection_initializer

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

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




    def object_or_collection_initializer(self):

        localctx = CSharpParser.Object_or_collection_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_object_or_collection_initializer)
        try:
            self.state = 840
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 838
                self.object_initializer()
                pass

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


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


    class Object_initializerContext(ParserRuleContext):

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

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

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_object_initializer

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

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




    def object_initializer(self):

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




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


    class Member_initializer_listContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_member_initializer_list

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

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




    def member_initializer_list(self):

        localctx = CSharpParser.Member_initializer_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_member_initializer_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 851
            self.member_initializer()
            self.state = 856
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,65,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 852
                    self.match(CSharpParser.COMMA)
                    self.state = 853
                    self.member_initializer() 
                self.state = 858
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,65,self._ctx)

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


    class Member_initializerContext(ParserRuleContext):

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

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

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


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


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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_member_initializer

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

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




    def member_initializer(self):

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

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


    class Initializer_valueContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_initializer_value

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

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




    def initializer_value(self):

        localctx = CSharpParser.Initializer_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_initializer_value)
        try:
            self.state = 871
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 869
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 870
                self.object_or_collection_initializer()
                pass
            else:
                raise NoViableAltException(self)

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


    class Collection_initializerContext(ParserRuleContext):

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

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

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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_collection_initializer

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

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




    def collection_initializer(self):

        localctx = CSharpParser.Collection_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_collection_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 873
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 874
            self.element_initializer()
            self.state = 879
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,68,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 875
                    self.match(CSharpParser.COMMA)
                    self.state = 876
                    self.element_initializer() 
                self.state = 881
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,68,self._ctx)

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


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


    class Element_initializerContext(ParserRuleContext):

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

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


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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_element_initializer

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

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




    def element_initializer(self):

        localctx = CSharpParser.Element_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_element_initializer)
        try:
            self.state = 892
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 887
                self.non_assignment_expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 888
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 889
                self.expression_list()
                self.state = 890
                self.match(CSharpParser.CLOSE_BRACE)
                pass
            else:
                raise NoViableAltException(self)

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


    class Anonymous_object_initializerContext(ParserRuleContext):

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

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

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_anonymous_object_initializer

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

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




    def anonymous_object_initializer(self):

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




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


    class Member_declarator_listContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_member_declarator_list

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

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




    def member_declarator_list(self):

        localctx = CSharpParser.Member_declarator_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_member_declarator_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 903
            self.member_declarator()
            self.state = 908
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,73,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 904
                    self.match(CSharpParser.COMMA)
                    self.state = 905
                    self.member_declarator() 
                self.state = 910
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,73,self._ctx)

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


    class Member_declaratorContext(ParserRuleContext):

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

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


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


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_member_declarator

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

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




    def member_declarator(self):

        localctx = CSharpParser.Member_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_member_declarator)
        try:
            self.state = 916
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 911
                self.primary_expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 912
                self.identifier()
                self.state = 913
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 914
                self.expression()
                pass


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


    class Unbound_type_nameContext(ParserRuleContext):

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

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


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

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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_unbound_type_name

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

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




    def unbound_type_name(self):

        localctx = CSharpParser.Unbound_type_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_unbound_type_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 918
            self.identifier()
            self.state = 927
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.CLOSE_PARENS, CSharpParser.DOT, CSharpParser.LT]:
                self.state = 920
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 919
                    self.generic_dimension_specifier()


                pass
            elif token in [CSharpParser.DOUBLE_COLON]:
                self.state = 922
                self.match(CSharpParser.DOUBLE_COLON)
                self.state = 923
                self.identifier()
                self.state = 925
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 924
                    self.generic_dimension_specifier()


                pass
            else:
                raise NoViableAltException(self)

            self.state = 936
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.DOT:
                self.state = 929
                self.match(CSharpParser.DOT)
                self.state = 930
                self.identifier()
                self.state = 932
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 931
                    self.generic_dimension_specifier()


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

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


    class Generic_dimension_specifierContext(ParserRuleContext):

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

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

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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_generic_dimension_specifier

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

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




    def generic_dimension_specifier(self):

        localctx = CSharpParser.Generic_dimension_specifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_generic_dimension_specifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 939
            self.match(CSharpParser.LT)
            self.state = 943
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 940
                self.match(CSharpParser.COMMA)
                self.state = 945
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class IsTypeContext(ParserRuleContext):

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

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


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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_isType

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

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




    def isType(self):

        localctx = CSharpParser.IsTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_isType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 948
            self.base_type()
            self.state = 953
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,82,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 951
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.OPEN_BRACKET]:
                        self.state = 949
                        self.rank_specifier()
                        pass
                    elif token in [CSharpParser.STAR]:
                        self.state = 950
                        self.match(CSharpParser.STAR)
                        pass
                    else:
                        raise NoViableAltException(self)
             
                self.state = 955
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,82,self._ctx)

            self.state = 957
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,83,self._ctx)
            if la_ == 1:
                self.state = 956
                self.match(CSharpParser.INTERR)


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


    class Lambda_expressionContext(ParserRuleContext):

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

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


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


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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_lambda_expression

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

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




    def lambda_expression(self):

        localctx = CSharpParser.Lambda_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_lambda_expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 960
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.state = 959
                self.match(CSharpParser.ASYNC)


            self.state = 962
            self.anonymous_function_signature()
            self.state = 963
            self.right_arrow()
            self.state = 964
            self.anonymous_function_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Anonymous_function_signatureContext(ParserRuleContext):

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

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

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

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


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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_anonymous_function_signature

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

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




    def anonymous_function_signature(self):

        localctx = CSharpParser.Anonymous_function_signatureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_anonymous_function_signature)
        try:
            self.state = 977
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,85,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 966
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 967
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 968
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 969
                self.explicit_anonymous_function_parameter_list()
                self.state = 970
                self.match(CSharpParser.CLOSE_PARENS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 972
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 973
                self.implicit_anonymous_function_parameter_list()
                self.state = 974
                self.match(CSharpParser.CLOSE_PARENS)
                pass

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


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


    class Explicit_anonymous_function_parameter_listContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_explicit_anonymous_function_parameter_list

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

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




    def explicit_anonymous_function_parameter_list(self):

        localctx = CSharpParser.Explicit_anonymous_function_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_explicit_anonymous_function_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 979
            self.explicit_anonymous_function_parameter()
            self.state = 984
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 980
                self.match(CSharpParser.COMMA)
                self.state = 981
                self.explicit_anonymous_function_parameter()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Explicit_anonymous_function_parameterContext(ParserRuleContext):

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_explicit_anonymous_function_parameter

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

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




    def explicit_anonymous_function_parameter(self):

        localctx = CSharpParser.Explicit_anonymous_function_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_explicit_anonymous_function_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 988
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OUT or _la==CSharpParser.REF:
                self.state = 987
                localctx.refout = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==CSharpParser.OUT or _la==CSharpParser.REF):
                    localctx.refout = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 990
            self.cstype()
            self.state = 991
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Implicit_anonymous_function_parameter_listContext(ParserRuleContext):

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_implicit_anonymous_function_parameter_list

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

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




    def implicit_anonymous_function_parameter_list(self):

        localctx = CSharpParser.Implicit_anonymous_function_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_implicit_anonymous_function_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 993
            self.identifier()
            self.state = 998
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 994
                self.match(CSharpParser.COMMA)
                self.state = 995
                self.identifier()
                self.state = 1000
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class Anonymous_function_bodyContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_anonymous_function_body

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

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




    def anonymous_function_body(self):

        localctx = CSharpParser.Anonymous_function_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_anonymous_function_body)
        try:
            self.state = 1003
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1001
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1002
                self.block()
                pass
            else:
                raise NoViableAltException(self)

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


    class Query_expressionContext(ParserRuleContext):

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

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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_query_expression

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

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




    def query_expression(self):

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


    class From_clauseContext(ParserRuleContext):

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

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

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


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

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


        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_from_clause

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

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




    def from_clause(self):

        localctx = CSharpParser.From_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_from_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1008
            self.match(CSharpParser.FROM)
            self.state = 1010
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.state = 1009
                self.cstype()


            self.state = 1012
            self.identifier()
            self.state = 1013
            self.match(CSharpParser.IN)
            self.state = 1014
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Query_bodyContext(ParserRuleContext):

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

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


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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_query_body

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

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




    def query_body(self):

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

            self.state = 1022
            self.select_or_group_clause()
            self.state = 1024
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,92,self._ctx)
            if la_ == 1:
                self.state = 1023
                self.query_continuation()


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


    class Query_body_clauseContext(ParserRuleContext):

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

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


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


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


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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_query_body_clause

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

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




    def query_body_clause(self):

        localctx = CSharpParser.Query_body_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_query_body_clause)
        try:
            self.state = 1031
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.FROM]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1026
                self.from_clause()
                pass
            elif token in [CSharpParser.LET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1027
                self.let_clause()
                pass
            elif token in [CSharpParser.WHERE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1028
                self.where_clause()
                pass
            elif token in [CSharpParser.JOIN]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1029
                self.combined_join_clause()
                pass
            elif token in [CSharpParser.ORDERBY]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1030
                self.orderby_clause()
                pass
            else:
                raise NoViableAltException(self)

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


    class Let_clauseContext(ParserRuleContext):

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

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

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


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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_let_clause

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

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




    def let_clause(self):

        localctx = CSharpParser.Let_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_let_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1033
            self.match(CSharpParser.LET)
            self.state = 1034
            self.identifier()
            self.state = 1035
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 1036
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Where_clauseContext(ParserRuleContext):

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

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

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


        def getRuleIndex(self):
            return CSharpParser.RULE_where_clause

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

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




    def where_clause(self):

        localctx = CSharpParser.Where_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_where_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1038
            self.match(CSharpParser.WHERE)
            self.state = 1039
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Combined_join_clauseContext(ParserRuleContext):

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

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

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


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

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


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

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


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

        def getRuleIndex(self):
            return CSharpParser.RULE_combined_join_clause

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

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




    def combined_join_clause(self):

        localctx = CSharpParser.Combined_join_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_combined_join_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1041
            self.match(CSharpParser.JOIN)
            self.state = 1043
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.state = 1042
                self.cstype()


            self.state = 1045
            self.identifier()
            self.state = 1046
            self.match(CSharpParser.IN)
            self.state = 1047
            self.expression()
            self.state = 1048
            self.match(CSharpParser.ON)
            self.state = 1049
            self.expression()
            self.state = 1050
            self.match(CSharpParser.EQUALS)
            self.state = 1051
            self.expression()
            self.state = 1054
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.INTO:
                self.state = 1052
                self.match(CSharpParser.INTO)
                self.state = 1053
                self.identifier()


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


    class Orderby_clauseContext(ParserRuleContext):

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

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

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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_orderby_clause

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

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




    def orderby_clause(self):

        localctx = CSharpParser.Orderby_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_orderby_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1056
            self.match(CSharpParser.ORDERBY)
            self.state = 1057
            self.ordering()
            self.state = 1062
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1058
                self.match(CSharpParser.COMMA)
                self.state = 1059
                self.ordering()
                self.state = 1064
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class OrderingContext(ParserRuleContext):

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

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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_ordering

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

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




    def ordering(self):

        localctx = CSharpParser.OrderingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_ordering)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1065
            self.expression()
            self.state = 1067
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASCENDING or _la==CSharpParser.DESCENDING:
                self.state = 1066
                localctx.csdir = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==CSharpParser.ASCENDING or _la==CSharpParser.DESCENDING):
                    localctx.csdir = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


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


    class Select_or_group_clauseContext(ParserRuleContext):

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

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

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


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

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

        def getRuleIndex(self):
            return CSharpParser.RULE_select_or_group_clause

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

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




    def select_or_group_clause(self):

        localctx = CSharpParser.Select_or_group_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_select_or_group_clause)
        try:
            self.state = 1076
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.SELECT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1069
                self.match(CSharpParser.SELECT)
                self.state = 1070
                self.expression()
                pass
            elif token in [CSharpParser.GROUP]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1071
                self.match(CSharpParser.GROUP)
                self.state = 1072
                self.expression()
                self.state = 1073
                self.match(CSharpParser.BY)
                self.state = 1074
                self.expression()
                pass
            else:
                raise NoViableAltException(self)

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


    class Query_continuationContext(ParserRuleContext):

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

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

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


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


        def getRuleIndex(self):
            return CSharpParser.RULE_query_continuation

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

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




    def query_continuation(self):

        localctx = CSharpParser.Query_continuationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_query_continuation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1078
            self.match(CSharpParser.INTO)
            self.state = 1079
            self.identifier()
            self.state = 1080
            self.query_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return CSharpParser.RULE_statement

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



    class DeclarationStatementContext(StatementContext):

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

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)
        def local_variable_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)

        def local_constant_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_constant_declarationContext,0)


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

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


    class EmbeddedStatementContext(StatementContext):

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

        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)


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

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


    class LabeledStatementContext(StatementContext):

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

        def labeled_Statement(self):
            return self.getTypedRuleContext(CSharpParser.Labeled_StatementContext,0)


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

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



    def statement(self):

        localctx = CSharpParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_statement)
        try:
            self.state = 1090
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
            if la_ == 1:
                localctx = CSharpParser.LabeledStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1082
                self.labeled_Statement()
                pass

            elif la_ == 2:
                localctx = CSharpParser.DeclarationStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1085
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                    self.state = 1083
                    self.local_variable_declaration()
                    pass
                elif token in [CSharpParser.CONST]:
                    self.state = 1084
                    self.local_constant_declaration()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1087
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                localctx = CSharpParser.EmbeddedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1089
                self.embedded_statement()
                pass


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


    class Labeled_StatementContext(ParserRuleContext):

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

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


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

        def statement(self):
            return self.getTypedRuleContext(CSharpParser.StatementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_labeled_Statement

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

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




    def labeled_Statement(self):

        localctx = CSharpParser.Labeled_StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_labeled_Statement)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1092
            self.identifier()
            self.state = 1093
            self.match(CSharpParser.COLON)
            self.state = 1094
            self.statement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Embedded_statementContext(ParserRuleContext):

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

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


        def simple_embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Simple_embedded_statementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_embedded_statement

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

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




    def embedded_statement(self):

        localctx = CSharpParser.Embedded_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_embedded_statement)
        try:
            self.state = 1098
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1096
                self.block()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GOTO, CSharpParser.GROUP, CSharpParser.IF, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.WHILE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.SEMICOLON, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1097
                self.simple_embedded_statement()
                pass
            else:
                raise NoViableAltException(self)

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


    class Simple_embedded_statementContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return CSharpParser.RULE_simple_embedded_statement

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



    class EmptyStatementContext(Simple_embedded_statementContext):

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

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

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

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


    class TryStatementContext(Simple_embedded_statementContext):

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

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

        def catch_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Catch_clausesContext,0)

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


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

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


    class CheckedStatementContext(Simple_embedded_statementContext):

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

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


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

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


    class ThrowStatementContext(Simple_embedded_statementContext):

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

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


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

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


    class UnsafeStatementContext(Simple_embedded_statementContext):

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

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


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

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


    class ForStatementContext(Simple_embedded_statementContext):

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

        def FOR(self):
            return self.getToken(CSharpParser.FOR, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def SEMICOLON(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.SEMICOLON)
            else:
                return self.getToken(CSharpParser.SEMICOLON, i)
        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

        def for_initializer(self):
            return self.getTypedRuleContext(CSharpParser.For_initializerContext,0)

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

        def for_iterator(self):
            return self.getTypedRuleContext(CSharpParser.For_iteratorContext,0)


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

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


    class BreakStatementContext(Simple_embedded_statementContext):

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

        def BREAK(self):
            return self.getToken(CSharpParser.BREAK, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class IfStatementContext(Simple_embedded_statementContext):

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

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

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def if_body(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.If_bodyContext)
            else:
                return self.getTypedRuleContext(CSharpParser.If_bodyContext,i)

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

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

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


    class ReturnStatementContext(Simple_embedded_statementContext):

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

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


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

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


    class GotoStatementContext(Simple_embedded_statementContext):

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

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

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

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

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

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


    class SwitchStatementContext(Simple_embedded_statementContext):

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

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

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)
        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)
        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)
        def switch_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Switch_sectionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Switch_sectionContext,i)


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

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


    class FixedStatementContext(Simple_embedded_statementContext):

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

        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def pointer_type(self):
            return self.getTypedRuleContext(CSharpParser.Pointer_typeContext,0)

        def fixed_pointer_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorsContext,0)

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


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

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


    class WhileStatementContext(Simple_embedded_statementContext):

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

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

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


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

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


    class DoStatementContext(Simple_embedded_statementContext):

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

        def DO(self):
            return self.getToken(CSharpParser.DO, 0)
        def embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

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

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

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

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


    class ForeachStatementContext(Simple_embedded_statementContext):

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

        def FOREACH(self):
            return self.getToken(CSharpParser.FOREACH, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def local_variable_type(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_typeContext,0)

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

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

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


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

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


    class UncheckedStatementContext(Simple_embedded_statementContext):

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

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


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

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


    class ExpressionStatementContext(Simple_embedded_statementContext):

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

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

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

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

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


    class ContinueStatementContext(Simple_embedded_statementContext):

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

        def CONTINUE(self):
            return self.getToken(CSharpParser.CONTINUE, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

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

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


    class UsingStatementContext(Simple_embedded_statementContext):

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

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)
        def resource_acquisition(self):
            return self.getTypedRuleContext(CSharpParser.Resource_acquisitionContext,0)

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


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

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


    class LockStatementContext(Simple_embedded_statementContext):

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

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

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


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

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


    class YieldStatementContext(Simple_embedded_statementContext):

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

        def YIELD(self):
            return self.getToken(CSharpParser.YIELD, 0)
        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)
        def RETURN(self):
            return self.getToken(CSharpParser.RETURN, 0)
        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

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

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

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



    def simple_embedded_statement(self):

        localctx = CSharpParser.Simple_embedded_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_simple_embedded_statement)
        self._la = 0 # Token type
        try:
            self.state = 1227
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                localctx = CSharpParser.EmptyStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1100
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                localctx = CSharpParser.ExpressionStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1101
                self.expression()
                self.state = 1102
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                localctx = CSharpParser.IfStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1104
                self.match(CSharpParser.IF)
                self.state = 1105
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1106
                self.expression()
                self.state = 1107
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1108
                self.if_body()
                self.state = 1111
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
                if la_ == 1:
                    self.state = 1109
                    self.match(CSharpParser.ELSE)
                    self.state = 1110
                    self.if_body()


                pass

            elif la_ == 4:
                localctx = CSharpParser.SwitchStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 1113
                self.match(CSharpParser.SWITCH)
                self.state = 1114
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1115
                self.expression()
                self.state = 1116
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1117
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 1121
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.CASE or _la==CSharpParser.DEFAULT:
                    self.state = 1118
                    self.switch_section()
                    self.state = 1123
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1124
                self.match(CSharpParser.CLOSE_BRACE)
                pass

            elif la_ == 5:
                localctx = CSharpParser.WhileStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 1126
                self.match(CSharpParser.WHILE)
                self.state = 1127
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1128
                self.expression()
                self.state = 1129
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1130
                self.embedded_statement()
                pass

            elif la_ == 6:
                localctx = CSharpParser.DoStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 1132
                self.match(CSharpParser.DO)
                self.state = 1133
                self.embedded_statement()
                self.state = 1134
                self.match(CSharpParser.WHILE)
                self.state = 1135
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1136
                self.expression()
                self.state = 1137
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1138
                self.match(CSharpParser.SEMICOLON)
                pass

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


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


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


                self.state = 1153
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1154
                self.embedded_statement()
                pass

            elif la_ == 8:
                localctx = CSharpParser.ForeachStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 1155
                self.match(CSharpParser.FOREACH)
                self.state = 1156
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1157
                self.local_variable_type()
                self.state = 1158
                self.identifier()
                self.state = 1159
                self.match(CSharpParser.IN)
                self.state = 1160
                self.expression()
                self.state = 1161
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1162
                self.embedded_statement()
                pass

            elif la_ == 9:
                localctx = CSharpParser.BreakStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 9)
                self.state = 1164
                self.match(CSharpParser.BREAK)
                self.state = 1165
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 10:
                localctx = CSharpParser.ContinueStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 10)
                self.state = 1166
                self.match(CSharpParser.CONTINUE)
                self.state = 1167
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 11:
                localctx = CSharpParser.GotoStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 11)
                self.state = 1168
                self.match(CSharpParser.GOTO)
                self.state = 1173
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                    self.state = 1169
                    self.identifier()
                    pass
                elif token in [CSharpParser.CASE]:
                    self.state = 1170
                    self.match(CSharpParser.CASE)
                    self.state = 1171
                    self.expression()
                    pass
                elif token in [CSharpParser.DEFAULT]:
                    self.state = 1172
                    self.match(CSharpParser.DEFAULT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1175
                self.match(CSharpParser.SEMICOLON)
                pass

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


                self.state = 1180
                self.match(CSharpParser.SEMICOLON)
                pass

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


                self.state = 1185
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 14:
                localctx = CSharpParser.TryStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 14)
                self.state = 1186
                self.match(CSharpParser.TRY)
                self.state = 1187
                self.block()
                self.state = 1193
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.CATCH]:
                    self.state = 1188
                    self.catch_clauses()
                    self.state = 1190
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.FINALLY:
                        self.state = 1189
                        self.finally_clause()


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

                pass

            elif la_ == 15:
                localctx = CSharpParser.CheckedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 15)
                self.state = 1195
                self.match(CSharpParser.CHECKED)
                self.state = 1196
                self.block()
                pass

            elif la_ == 16:
                localctx = CSharpParser.UncheckedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 16)
                self.state = 1197
                self.match(CSharpParser.UNCHECKED)
                self.state = 1198
                self.block()
                pass

            elif la_ == 17:
                localctx = CSharpParser.LockStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 17)
                self.state = 1199
                self.match(CSharpParser.LOCK)
                self.state = 1200
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1201
                self.expression()
                self.state = 1202
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1203
                self.embedded_statement()
                pass

            elif la_ == 18:
                localctx = CSharpParser.UsingStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 18)
                self.state = 1205
                self.match(CSharpParser.USING)
                self.state = 1206
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1207
                self.resource_acquisition()
                self.state = 1208
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1209
                self.embedded_statement()
                pass

            elif la_ == 19:
                localctx = CSharpParser.YieldStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 19)
                self.state = 1211
                self.match(CSharpParser.YIELD)
                self.state = 1215
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.RETURN]:
                    self.state = 1212
                    self.match(CSharpParser.RETURN)
                    self.state = 1213
                    self.expression()
                    pass
                elif token in [CSharpParser.BREAK]:
                    self.state = 1214
                    self.match(CSharpParser.BREAK)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1217
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 20:
                localctx = CSharpParser.UnsafeStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 20)
                self.state = 1218
                self.match(CSharpParser.UNSAFE)
                self.state = 1219
                self.block()
                pass

            elif la_ == 21:
                localctx = CSharpParser.FixedStatementContext(self, localctx)
                self.enterOuterAlt(localctx, 21)
                self.state = 1220
                self.match(CSharpParser.FIXED)
                self.state = 1221
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1222
                self.pointer_type()
                self.state = 1223
                self.fixed_pointer_declarators()
                self.state = 1224
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1225
                self.embedded_statement()
                pass


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


    class BlockContext(ParserRuleContext):

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

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

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

        def statement_list(self):
            return self.getTypedRuleContext(CSharpParser.Statement_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_block

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

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




    def block(self):

        localctx = CSharpParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1229
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1231
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BREAK) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.CONST) | (1 << CSharpParser.CONTINUE) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DO) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FIXED) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FOR) | (1 << CSharpParser.FOREACH) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GOTO) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IF) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LOCK) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.RETURN - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.SWITCH - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.THROW - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TRY - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.USING - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.WHILE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_BRACE - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 131)) & ~0x3f) == 0 and ((1 << (_la - 131)) & ((1 << (CSharpParser.SEMICOLON - 131)) | (1 << (CSharpParser.PLUS - 131)) | (1 << (CSharpParser.MINUS - 131)) | (1 << (CSharpParser.STAR - 131)) | (1 << (CSharpParser.AMP - 131)) | (1 << (CSharpParser.BANG - 131)) | (1 << (CSharpParser.TILDE - 131)) | (1 << (CSharpParser.OP_INC - 131)) | (1 << (CSharpParser.OP_DEC - 131)))) != 0):
                self.state = 1230
                self.statement_list()


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


    class Local_variable_declarationContext(ParserRuleContext):

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

        def local_variable_type(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_typeContext,0)


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


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

        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_declaration

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

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




    def local_variable_declaration(self):

        localctx = CSharpParser.Local_variable_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_local_variable_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1235
            self.local_variable_type()
            self.state = 1236
            self.local_variable_declarator()
            self.state = 1241
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1237
                self.match(CSharpParser.COMMA)
                self.state = 1238
                self.local_variable_declarator()
                self.state = 1243
                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 Local_variable_typeContext(ParserRuleContext):

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

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_type

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

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




    def local_variable_type(self):

        localctx = CSharpParser.Local_variable_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_local_variable_type)
        try:
            self.state = 1246
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1244
                self.match(CSharpParser.VAR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1245
                self.cstype()
                pass


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


    class Local_variable_declaratorContext(ParserRuleContext):

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

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


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

        def local_variable_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_declarator

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

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




    def local_variable_declarator(self):

        localctx = CSharpParser.Local_variable_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_local_variable_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1248
            self.identifier()
            self.state = 1251
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 1249
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1250
                self.local_variable_initializer()


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


    class Local_variable_initializerContext(ParserRuleContext):

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

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


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


        def local_variable_initializer_unsafe(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_initializer_unsafeContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_initializer

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

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




    def local_variable_initializer(self):

        localctx = CSharpParser.Local_variable_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_local_variable_initializer)
        try:
            self.state = 1256
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1253
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1254
                self.array_initializer()
                pass
            elif token in [CSharpParser.STACKALLOC]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1255
                self.local_variable_initializer_unsafe()
                pass
            else:
                raise NoViableAltException(self)

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


    class Local_constant_declarationContext(ParserRuleContext):

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

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

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def constant_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Constant_declaratorsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_local_constant_declaration

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

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




    def local_constant_declaration(self):

        localctx = CSharpParser.Local_constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_local_constant_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1258
            self.match(CSharpParser.CONST)
            self.state = 1259
            self.cstype()
            self.state = 1260
            self.constant_declarators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class If_bodyContext(ParserRuleContext):

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

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


        def simple_embedded_statement(self):
            return self.getTypedRuleContext(CSharpParser.Simple_embedded_statementContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_if_body

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

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




    def if_body(self):

        localctx = CSharpParser.If_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_if_body)
        try:
            self.state = 1264
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1262
                self.block()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GOTO, CSharpParser.GROUP, CSharpParser.IF, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.WHILE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.SEMICOLON, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1263
                self.simple_embedded_statement()
                pass
            else:
                raise NoViableAltException(self)

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


    class Switch_sectionContext(ParserRuleContext):

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

        def statement_list(self):
            return self.getTypedRuleContext(CSharpParser.Statement_listContext,0)


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


        def getRuleIndex(self):
            return CSharpParser.RULE_switch_section

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

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




    def switch_section(self):

        localctx = CSharpParser.Switch_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_switch_section)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1267 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1266
                    self.switch_label()

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

            self.state = 1271
            self.statement_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Switch_labelContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CASE(self):
            return self.getToken(CSharpParser.CASE, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_switch_label

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSwitch_label" ):
                listener.enterSwitch_label(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSwitch_label" ):
                listener.exitSwitch_label(self)




    def switch_label(self):

        localctx = CSharpParser.Switch_labelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_switch_label)
        try:
            self.state = 1279
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.CASE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1273
                self.match(CSharpParser.CASE)
                self.state = 1274
                self.expression()
                self.state = 1275
                self.match(CSharpParser.COLON)
                pass
            elif token in [CSharpParser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1277
                self.match(CSharpParser.DEFAULT)
                self.state = 1278
                self.match(CSharpParser.COLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.StatementContext)
            else:
                return self.getTypedRuleContext(CSharpParser.StatementContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_statement_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement_list" ):
                listener.enterStatement_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement_list" ):
                listener.exitStatement_list(self)




    def statement_list(self):

        localctx = CSharpParser.Statement_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_statement_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1282 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1281
                    self.statement()

                else:
                    raise NoViableAltException(self)
                self.state = 1284 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,122,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class For_initializerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def local_variable_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)


        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_for_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFor_initializer" ):
                listener.enterFor_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFor_initializer" ):
                listener.exitFor_initializer(self)




    def for_initializer(self):

        localctx = CSharpParser.For_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_for_initializer)
        self._la = 0 # Token type
        try:
            self.state = 1295
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,124,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1286
                self.local_variable_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1287
                self.expression()
                self.state = 1292
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.COMMA:
                    self.state = 1288
                    self.match(CSharpParser.COMMA)
                    self.state = 1289
                    self.expression()
                    self.state = 1294
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class For_iteratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_for_iterator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFor_iterator" ):
                listener.enterFor_iterator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFor_iterator" ):
                listener.exitFor_iterator(self)




    def for_iterator(self):

        localctx = CSharpParser.For_iteratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_for_iterator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1297
            self.expression()
            self.state = 1302
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1298
                self.match(CSharpParser.COMMA)
                self.state = 1299
                self.expression()
                self.state = 1304
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Catch_clausesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def specific_catch_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Specific_catch_clauseContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Specific_catch_clauseContext,i)


        def general_catch_clause(self):
            return self.getTypedRuleContext(CSharpParser.General_catch_clauseContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_catch_clauses

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCatch_clauses" ):
                listener.enterCatch_clauses(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCatch_clauses" ):
                listener.exitCatch_clauses(self)




    def catch_clauses(self):

        localctx = CSharpParser.Catch_clausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_catch_clauses)
        self._la = 0 # Token type
        try:
            self.state = 1316
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,128,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1305
                self.specific_catch_clause()
                self.state = 1309
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,126,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1306
                        self.specific_catch_clause() 
                    self.state = 1311
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,126,self._ctx)

                self.state = 1313
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.CATCH:
                    self.state = 1312
                    self.general_catch_clause()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1315
                self.general_catch_clause()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Specific_catch_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CATCH(self):
            return self.getToken(CSharpParser.CATCH, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def exception_filter(self):
            return self.getTypedRuleContext(CSharpParser.Exception_filterContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_specific_catch_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSpecific_catch_clause" ):
                listener.enterSpecific_catch_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSpecific_catch_clause" ):
                listener.exitSpecific_catch_clause(self)




    def specific_catch_clause(self):

        localctx = CSharpParser.Specific_catch_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_specific_catch_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1318
            self.match(CSharpParser.CATCH)
            self.state = 1319
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1320
            self.class_type()
            self.state = 1322
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CSharpParser.ON - 68)) | (1 << (CSharpParser.ORDERBY - 68)) | (1 << (CSharpParser.PARTIAL - 68)) | (1 << (CSharpParser.REMOVE - 68)) | (1 << (CSharpParser.SELECT - 68)) | (1 << (CSharpParser.SET - 68)) | (1 << (CSharpParser.VAR - 68)) | (1 << (CSharpParser.WHEN - 68)) | (1 << (CSharpParser.WHERE - 68)) | (1 << (CSharpParser.YIELD - 68)) | (1 << (CSharpParser.IDENTIFIER - 68)))) != 0):
                self.state = 1321
                self.identifier()


            self.state = 1324
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 1326
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHEN:
                self.state = 1325
                self.exception_filter()


            self.state = 1328
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class General_catch_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CATCH(self):
            return self.getToken(CSharpParser.CATCH, 0)

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def exception_filter(self):
            return self.getTypedRuleContext(CSharpParser.Exception_filterContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_general_catch_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGeneral_catch_clause" ):
                listener.enterGeneral_catch_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGeneral_catch_clause" ):
                listener.exitGeneral_catch_clause(self)




    def general_catch_clause(self):

        localctx = CSharpParser.General_catch_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_general_catch_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1330
            self.match(CSharpParser.CATCH)
            self.state = 1332
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHEN:
                self.state = 1331
                self.exception_filter()


            self.state = 1334
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Exception_filterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHEN(self):
            return self.getToken(CSharpParser.WHEN, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_exception_filter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterException_filter" ):
                listener.enterException_filter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitException_filter" ):
                listener.exitException_filter(self)




    def exception_filter(self):

        localctx = CSharpParser.Exception_filterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_exception_filter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1336
            self.match(CSharpParser.WHEN)
            self.state = 1337
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1338
            self.expression()
            self.state = 1339
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Finally_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FINALLY(self):
            return self.getToken(CSharpParser.FINALLY, 0)

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_finally_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFinally_clause" ):
                listener.enterFinally_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFinally_clause" ):
                listener.exitFinally_clause(self)




    def finally_clause(self):

        localctx = CSharpParser.Finally_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_finally_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1341
            self.match(CSharpParser.FINALLY)
            self.state = 1342
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Resource_acquisitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def local_variable_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)


        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_resource_acquisition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResource_acquisition" ):
                listener.enterResource_acquisition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResource_acquisition" ):
                listener.exitResource_acquisition(self)




    def resource_acquisition(self):

        localctx = CSharpParser.Resource_acquisitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_resource_acquisition)
        try:
            self.state = 1346
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,132,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1344
                self.local_variable_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1345
                self.expression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Namespace_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.qi = None # Qualified_identifierContext

        def NAMESPACE(self):
            return self.getToken(CSharpParser.NAMESPACE, 0)

        def namespace_body(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_bodyContext,0)


        def qualified_identifier(self):
            return self.getTypedRuleContext(CSharpParser.Qualified_identifierContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespace_declaration" ):
                listener.enterNamespace_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespace_declaration" ):
                listener.exitNamespace_declaration(self)




    def namespace_declaration(self):

        localctx = CSharpParser.Namespace_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_namespace_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1348
            self.match(CSharpParser.NAMESPACE)
            self.state = 1349
            localctx.qi = self.qualified_identifier()
            self.state = 1350
            self.namespace_body()
            self.state = 1352
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 1351
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qualified_identifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.DOT)
            else:
                return self.getToken(CSharpParser.DOT, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_qualified_identifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualified_identifier" ):
                listener.enterQualified_identifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualified_identifier" ):
                listener.exitQualified_identifier(self)




    def qualified_identifier(self):

        localctx = CSharpParser.Qualified_identifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_qualified_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1354
            self.identifier()
            self.state = 1359
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.DOT:
                self.state = 1355
                self.match(CSharpParser.DOT)
                self.state = 1356
                self.identifier()
                self.state = 1361
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Namespace_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def extern_alias_directives(self):
            return self.getTypedRuleContext(CSharpParser.Extern_alias_directivesContext,0)


        def using_directives(self):
            return self.getTypedRuleContext(CSharpParser.Using_directivesContext,0)


        def namespace_member_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespace_body" ):
                listener.enterNamespace_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespace_body" ):
                listener.exitNamespace_body(self)




    def namespace_body(self):

        localctx = CSharpParser.Namespace_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_namespace_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1362
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1364
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,135,self._ctx)
            if la_ == 1:
                self.state = 1363
                self.extern_alias_directives()


            self.state = 1367
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.USING:
                self.state = 1366
                self.using_directives()


            self.state = 1370
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.SINGLE_LINE_DOC_COMMENT) | (1 << CSharpParser.SINGLE_LINE_COMMENT) | (1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMESPACE - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.OVERRIDE - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.PRIVATE - 64)) | (1 << (CSharpParser.PROTECTED - 64)) | (1 << (CSharpParser.PUBLIC - 64)) | (1 << (CSharpParser.READONLY - 64)) | (1 << (CSharpParser.SEALED - 64)) | (1 << (CSharpParser.STATIC - 64)) | (1 << (CSharpParser.STRUCT - 64)) | (1 << (CSharpParser.UNSAFE - 64)) | (1 << (CSharpParser.VIRTUAL - 64)) | (1 << (CSharpParser.VOLATILE - 64)) | (1 << (CSharpParser.OPEN_BRACKET - 64)))) != 0):
                self.state = 1369
                self.namespace_member_declarations()


            self.state = 1372
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Extern_alias_directivesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def extern_alias_directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Extern_alias_directiveContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Extern_alias_directiveContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_extern_alias_directives

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExtern_alias_directives" ):
                listener.enterExtern_alias_directives(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExtern_alias_directives" ):
                listener.exitExtern_alias_directives(self)




    def extern_alias_directives(self):

        localctx = CSharpParser.Extern_alias_directivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_extern_alias_directives)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1375 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1374
                    self.extern_alias_directive()

                else:
                    raise NoViableAltException(self)
                self.state = 1377 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,138,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Extern_alias_directiveContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXTERN(self):
            return self.getToken(CSharpParser.EXTERN, 0)

        def ALIAS(self):
            return self.getToken(CSharpParser.ALIAS, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_extern_alias_directive

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExtern_alias_directive" ):
                listener.enterExtern_alias_directive(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExtern_alias_directive" ):
                listener.exitExtern_alias_directive(self)




    def extern_alias_directive(self):

        localctx = CSharpParser.Extern_alias_directiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_extern_alias_directive)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1379
            self.match(CSharpParser.EXTERN)
            self.state = 1380
            self.match(CSharpParser.ALIAS)
            self.state = 1381
            self.identifier()
            self.state = 1382
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Using_directivesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def using_directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Using_directiveContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Using_directiveContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_using_directives

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsing_directives" ):
                listener.enterUsing_directives(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsing_directives" ):
                listener.exitUsing_directives(self)




    def using_directives(self):

        localctx = CSharpParser.Using_directivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_using_directives)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1385 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1384
                self.using_directive()
                self.state = 1387 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.USING):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Using_directiveContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return CSharpParser.RULE_using_directive

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class UsingAliasDirectiveContext(Using_directiveContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Using_directiveContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)
        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingAliasDirective" ):
                listener.enterUsingAliasDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingAliasDirective" ):
                listener.exitUsingAliasDirective(self)


    class UsingNamespaceDirectiveContext(Using_directiveContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Using_directiveContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingNamespaceDirective" ):
                listener.enterUsingNamespaceDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingNamespaceDirective" ):
                listener.exitUsingNamespaceDirective(self)


    class UsingStaticDirectiveContext(Using_directiveContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Using_directiveContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)
        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)
        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUsingStaticDirective" ):
                listener.enterUsingStaticDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUsingStaticDirective" ):
                listener.exitUsingStaticDirective(self)



    def using_directive(self):

        localctx = CSharpParser.Using_directiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_using_directive)
        try:
            self.state = 1404
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,140,self._ctx)
            if la_ == 1:
                localctx = CSharpParser.UsingAliasDirectiveContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 1389
                self.match(CSharpParser.USING)
                self.state = 1390
                self.identifier()
                self.state = 1391
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1392
                self.namespace_or_type_name()
                self.state = 1393
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                localctx = CSharpParser.UsingNamespaceDirectiveContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 1395
                self.match(CSharpParser.USING)
                self.state = 1396
                self.namespace_or_type_name()
                self.state = 1397
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                localctx = CSharpParser.UsingStaticDirectiveContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 1399
                self.match(CSharpParser.USING)
                self.state = 1400
                self.match(CSharpParser.STATIC)
                self.state = 1401
                self.namespace_or_type_name()
                self.state = 1402
                self.match(CSharpParser.SEMICOLON)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Namespace_member_declarationsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_member_declarations

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespace_member_declarations" ):
                listener.enterNamespace_member_declarations(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespace_member_declarations" ):
                listener.exitNamespace_member_declarations(self)




    def namespace_member_declarations(self):

        localctx = CSharpParser.Namespace_member_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_namespace_member_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1407 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1406
                self.namespace_member_declaration()
                self.state = 1409 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.SINGLE_LINE_DOC_COMMENT) | (1 << CSharpParser.SINGLE_LINE_COMMENT) | (1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMESPACE - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.OVERRIDE - 64)) | (1 << (CSharpParser.PARTIAL - 64)) | (1 << (CSharpParser.PRIVATE - 64)) | (1 << (CSharpParser.PROTECTED - 64)) | (1 << (CSharpParser.PUBLIC - 64)) | (1 << (CSharpParser.READONLY - 64)) | (1 << (CSharpParser.SEALED - 64)) | (1 << (CSharpParser.STATIC - 64)) | (1 << (CSharpParser.STRUCT - 64)) | (1 << (CSharpParser.UNSAFE - 64)) | (1 << (CSharpParser.VIRTUAL - 64)) | (1 << (CSharpParser.VOLATILE - 64)) | (1 << (CSharpParser.OPEN_BRACKET - 64)))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Namespace_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_declarationContext,0)


        def type_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Type_declarationContext,0)


        def documented_item(self):
            return self.getTypedRuleContext(CSharpParser.Documented_itemContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_namespace_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNamespace_member_declaration" ):
                listener.enterNamespace_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNamespace_member_declaration" ):
                listener.exitNamespace_member_declaration(self)




    def namespace_member_declaration(self):

        localctx = CSharpParser.Namespace_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_namespace_member_declaration)
        try:
            self.state = 1414
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.NAMESPACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1411
                self.namespace_declaration()
                pass
            elif token in [CSharpParser.ABSTRACT, CSharpParser.ASYNC, CSharpParser.CLASS, CSharpParser.DELEGATE, CSharpParser.ENUM, CSharpParser.EXTERN, CSharpParser.INTERFACE, CSharpParser.INTERNAL, CSharpParser.NEW, CSharpParser.OVERRIDE, CSharpParser.PARTIAL, CSharpParser.PRIVATE, CSharpParser.PROTECTED, CSharpParser.PUBLIC, CSharpParser.READONLY, CSharpParser.SEALED, CSharpParser.STATIC, CSharpParser.STRUCT, CSharpParser.UNSAFE, CSharpParser.VIRTUAL, CSharpParser.VOLATILE, CSharpParser.OPEN_BRACKET]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1412
                self.type_declaration()
                pass
            elif token in [CSharpParser.SINGLE_LINE_DOC_COMMENT, CSharpParser.SINGLE_LINE_COMMENT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1413
                self.documented_item()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def class_definition(self):
            return self.getTypedRuleContext(CSharpParser.Class_definitionContext,0)


        def struct_definition(self):
            return self.getTypedRuleContext(CSharpParser.Struct_definitionContext,0)


        def interface_definition(self):
            return self.getTypedRuleContext(CSharpParser.Interface_definitionContext,0)


        def enum_definition(self):
            return self.getTypedRuleContext(CSharpParser.Enum_definitionContext,0)


        def delegate_definition(self):
            return self.getTypedRuleContext(CSharpParser.Delegate_definitionContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def all_member_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_declaration" ):
                listener.enterType_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_declaration" ):
                listener.exitType_declaration(self)




    def type_declaration(self):

        localctx = CSharpParser.Type_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_type_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1417
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1416
                self.attributes()


            self.state = 1420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOLATILE - 65)))) != 0):
                self.state = 1419
                self.all_member_modifiers()


            self.state = 1427
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.CLASS]:
                self.state = 1422
                self.class_definition()
                pass
            elif token in [CSharpParser.STRUCT]:
                self.state = 1423
                self.struct_definition()
                pass
            elif token in [CSharpParser.INTERFACE]:
                self.state = 1424
                self.interface_definition()
                pass
            elif token in [CSharpParser.ENUM]:
                self.state = 1425
                self.enum_definition()
                pass
            elif token in [CSharpParser.DELEGATE]:
                self.state = 1426
                self.delegate_definition()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qualified_alias_memberContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def DOUBLE_COLON(self):
            return self.getToken(CSharpParser.DOUBLE_COLON, 0)

        def type_argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_qualified_alias_member

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualified_alias_member" ):
                listener.enterQualified_alias_member(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualified_alias_member" ):
                listener.exitQualified_alias_member(self)




    def qualified_alias_member(self):

        localctx = CSharpParser.Qualified_alias_memberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_qualified_alias_member)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1429
            self.identifier()
            self.state = 1430
            self.match(CSharpParser.DOUBLE_COLON)
            self.state = 1431
            self.identifier()
            self.state = 1433
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,146,self._ctx)
            if la_ == 1:
                self.state = 1432
                self.type_argument_list()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameter_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def type_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_parameterContext,i)


        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_parameter_list" ):
                listener.enterType_parameter_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_parameter_list" ):
                listener.exitType_parameter_list(self)




    def type_parameter_list(self):

        localctx = CSharpParser.Type_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_type_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1435
            self.match(CSharpParser.LT)
            self.state = 1436
            self.type_parameter()
            self.state = 1441
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1437
                self.match(CSharpParser.COMMA)
                self.state = 1438
                self.type_parameter()
                self.state = 1443
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1444
            self.match(CSharpParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_parameter" ):
                listener.enterType_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_parameter" ):
                listener.exitType_parameter(self)




    def type_parameter(self):

        localctx = CSharpParser.Type_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_type_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1446
                self.attributes()


            self.state = 1449
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_baseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def namespace_or_type_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_base

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_base" ):
                listener.enterClass_base(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_base" ):
                listener.exitClass_base(self)




    def class_base(self):

        localctx = CSharpParser.Class_baseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_class_base)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1451
            self.match(CSharpParser.COLON)
            self.state = 1452
            self.class_type()
            self.state = 1457
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1453
                self.match(CSharpParser.COMMA)
                self.state = 1454
                self.namespace_or_type_name()
                self.state = 1459
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_type_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_or_type_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_interface_type_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_type_list" ):
                listener.enterInterface_type_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_type_list" ):
                listener.exitInterface_type_list(self)




    def interface_type_list(self):

        localctx = CSharpParser.Interface_type_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_interface_type_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1460
            self.namespace_or_type_name()
            self.state = 1465
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1461
                self.match(CSharpParser.COMMA)
                self.state = 1462
                self.namespace_or_type_name()
                self.state = 1467
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameter_constraints_clausesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def type_parameter_constraints_clause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_parameter_constraints_clauseContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clauseContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_constraints_clauses

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_parameter_constraints_clauses" ):
                listener.enterType_parameter_constraints_clauses(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_parameter_constraints_clauses" ):
                listener.exitType_parameter_constraints_clauses(self)




    def type_parameter_constraints_clauses(self):

        localctx = CSharpParser.Type_parameter_constraints_clausesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_type_parameter_constraints_clauses)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1469 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1468
                self.type_parameter_constraints_clause()
                self.state = 1471 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.WHERE):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameter_constraints_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHERE(self):
            return self.getToken(CSharpParser.WHERE, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def type_parameter_constraints(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraintsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_constraints_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_parameter_constraints_clause" ):
                listener.enterType_parameter_constraints_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_parameter_constraints_clause" ):
                listener.exitType_parameter_constraints_clause(self)




    def type_parameter_constraints_clause(self):

        localctx = CSharpParser.Type_parameter_constraints_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_type_parameter_constraints_clause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1473
            self.match(CSharpParser.WHERE)
            self.state = 1474
            self.identifier()
            self.state = 1475
            self.match(CSharpParser.COLON)
            self.state = 1476
            self.type_parameter_constraints()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_parameter_constraintsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constructor_constraint(self):
            return self.getTypedRuleContext(CSharpParser.Constructor_constraintContext,0)


        def primary_constraint(self):
            return self.getTypedRuleContext(CSharpParser.Primary_constraintContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def secondary_constraints(self):
            return self.getTypedRuleContext(CSharpParser.Secondary_constraintsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_type_parameter_constraints

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_parameter_constraints" ):
                listener.enterType_parameter_constraints(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_parameter_constraints" ):
                listener.exitType_parameter_constraints(self)




    def type_parameter_constraints(self):

        localctx = CSharpParser.Type_parameter_constraintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 210, self.RULE_type_parameter_constraints)
        self._la = 0 # Token type
        try:
            self.state = 1488
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.NEW]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1478
                self.constructor_constraint()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.CLASS, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1479
                self.primary_constraint()
                self.state = 1482
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,152,self._ctx)
                if la_ == 1:
                    self.state = 1480
                    self.match(CSharpParser.COMMA)
                    self.state = 1481
                    self.secondary_constraints()


                self.state = 1486
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1484
                    self.match(CSharpParser.COMMA)
                    self.state = 1485
                    self.constructor_constraint()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Primary_constraintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def CLASS(self):
            return self.getToken(CSharpParser.CLASS, 0)

        def STRUCT(self):
            return self.getToken(CSharpParser.STRUCT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_primary_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPrimary_constraint" ):
                listener.enterPrimary_constraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPrimary_constraint" ):
                listener.exitPrimary_constraint(self)




    def primary_constraint(self):

        localctx = CSharpParser.Primary_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 212, self.RULE_primary_constraint)
        try:
            self.state = 1493
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1490
                self.class_type()
                pass
            elif token in [CSharpParser.CLASS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1491
                self.match(CSharpParser.CLASS)
                pass
            elif token in [CSharpParser.STRUCT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1492
                self.match(CSharpParser.STRUCT)
                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 Secondary_constraintsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_or_type_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_secondary_constraints

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSecondary_constraints" ):
                listener.enterSecondary_constraints(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSecondary_constraints" ):
                listener.exitSecondary_constraints(self)




    def secondary_constraints(self):

        localctx = CSharpParser.Secondary_constraintsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 214, self.RULE_secondary_constraints)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1495
            self.namespace_or_type_name()
            self.state = 1500
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1496
                    self.match(CSharpParser.COMMA)
                    self.state = 1497
                    self.namespace_or_type_name() 
                self.state = 1502
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,156,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constructor_constraintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_constructor_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructor_constraint" ):
                listener.enterConstructor_constraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructor_constraint" ):
                listener.exitConstructor_constraint(self)




    def constructor_constraint(self):

        localctx = CSharpParser.Constructor_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 216, self.RULE_constructor_constraint)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1503
            self.match(CSharpParser.NEW)
            self.state = 1504
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1505
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def class_member_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Class_member_declarationsContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_body" ):
                listener.enterClass_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_body" ):
                listener.exitClass_body(self)




    def class_body(self):

        localctx = CSharpParser.Class_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 218, self.RULE_class_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1507
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1509
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.SINGLE_LINE_DOC_COMMENT) | (1 << CSharpParser.SINGLE_LINE_COMMENT) | (1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 0) or _la==CSharpParser.TILDE:
                self.state = 1508
                self.class_member_declarations()


            self.state = 1511
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_member_declarationsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def class_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Class_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Class_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_member_declarations

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_member_declarations" ):
                listener.enterClass_member_declarations(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_member_declarations" ):
                listener.exitClass_member_declarations(self)




    def class_member_declarations(self):

        localctx = CSharpParser.Class_member_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 220, self.RULE_class_member_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1514 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1513
                self.class_member_declaration()
                self.state = 1516 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.SINGLE_LINE_DOC_COMMENT) | (1 << CSharpParser.SINGLE_LINE_COMMENT) | (1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 0) or _la==CSharpParser.TILDE):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def documented_item(self):
            return self.getTypedRuleContext(CSharpParser.Documented_itemContext,0)


        def common_member_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Common_member_declarationContext,0)


        def destructor_definition(self):
            return self.getTypedRuleContext(CSharpParser.Destructor_definitionContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def all_member_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_class_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_member_declaration" ):
                listener.enterClass_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_member_declaration" ):
                listener.exitClass_member_declaration(self)




    def class_member_declaration(self):

        localctx = CSharpParser.Class_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 222, self.RULE_class_member_declaration)
        self._la = 0 # Token type
        try:
            self.state = 1529
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.SINGLE_LINE_DOC_COMMENT, CSharpParser.SINGLE_LINE_COMMENT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1518
                self.documented_item()
                pass
            elif token in [CSharpParser.ABSTRACT, CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.EXTERN, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTERNAL, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.OVERRIDE, CSharpParser.PARTIAL, CSharpParser.PRIVATE, CSharpParser.PROTECTED, CSharpParser.PUBLIC, CSharpParser.READONLY, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SEALED, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STATIC, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VIRTUAL, CSharpParser.VOID, CSharpParser.VOLATILE, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_BRACKET, CSharpParser.TILDE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1520
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.OPEN_BRACKET:
                    self.state = 1519
                    self.attributes()


                self.state = 1523
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,160,self._ctx)
                if la_ == 1:
                    self.state = 1522
                    self.all_member_modifiers()


                self.state = 1527
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                    self.state = 1525
                    self.common_member_declaration()
                    pass
                elif token in [CSharpParser.TILDE]:
                    self.state = 1526
                    self.destructor_definition()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class All_member_modifiersContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def all_member_modifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.All_member_modifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.All_member_modifierContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_all_member_modifiers

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAll_member_modifiers" ):
                listener.enterAll_member_modifiers(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAll_member_modifiers" ):
                listener.exitAll_member_modifiers(self)




    def all_member_modifiers(self):

        localctx = CSharpParser.All_member_modifiersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 224, self.RULE_all_member_modifiers)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1532 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1531
                    self.all_member_modifier()

                else:
                    raise NoViableAltException(self)
                self.state = 1534 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,163,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class All_member_modifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def PUBLIC(self):
            return self.getToken(CSharpParser.PUBLIC, 0)

        def PROTECTED(self):
            return self.getToken(CSharpParser.PROTECTED, 0)

        def INTERNAL(self):
            return self.getToken(CSharpParser.INTERNAL, 0)

        def PRIVATE(self):
            return self.getToken(CSharpParser.PRIVATE, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def VOLATILE(self):
            return self.getToken(CSharpParser.VOLATILE, 0)

        def VIRTUAL(self):
            return self.getToken(CSharpParser.VIRTUAL, 0)

        def SEALED(self):
            return self.getToken(CSharpParser.SEALED, 0)

        def OVERRIDE(self):
            return self.getToken(CSharpParser.OVERRIDE, 0)

        def ABSTRACT(self):
            return self.getToken(CSharpParser.ABSTRACT, 0)

        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def EXTERN(self):
            return self.getToken(CSharpParser.EXTERN, 0)

        def PARTIAL(self):
            return self.getToken(CSharpParser.PARTIAL, 0)

        def ASYNC(self):
            return self.getToken(CSharpParser.ASYNC, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_all_member_modifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAll_member_modifier" ):
                listener.enterAll_member_modifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAll_member_modifier" ):
                listener.exitAll_member_modifier(self)




    def all_member_modifier(self):

        localctx = CSharpParser.All_member_modifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 226, self.RULE_all_member_modifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1536
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOLATILE - 65)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Common_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constant_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Constant_declarationContext,0)


        def typed_member_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Typed_member_declarationContext,0)


        def event_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Event_declarationContext,0)


        def conversion_operator_declarator(self):
            return self.getTypedRuleContext(CSharpParser.Conversion_operator_declaratorContext,0)


        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def constructor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Constructor_declarationContext,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def method_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Method_declarationContext,0)


        def class_definition(self):
            return self.getTypedRuleContext(CSharpParser.Class_definitionContext,0)


        def struct_definition(self):
            return self.getTypedRuleContext(CSharpParser.Struct_definitionContext,0)


        def interface_definition(self):
            return self.getTypedRuleContext(CSharpParser.Interface_definitionContext,0)


        def enum_definition(self):
            return self.getTypedRuleContext(CSharpParser.Enum_definitionContext,0)


        def delegate_definition(self):
            return self.getTypedRuleContext(CSharpParser.Delegate_definitionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_common_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommon_member_declaration" ):
                listener.enterCommon_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommon_member_declaration" ):
                listener.exitCommon_member_declaration(self)




    def common_member_declaration(self):

        localctx = CSharpParser.Common_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 228, self.RULE_common_member_declaration)
        try:
            self.state = 1557
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1538
                self.constant_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1539
                self.typed_member_declaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1540
                self.event_declaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1541
                self.conversion_operator_declarator()
                self.state = 1547
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:
                    self.state = 1542
                    self.body()
                    pass
                elif token in [CSharpParser.ASSIGNMENT]:
                    self.state = 1543
                    self.right_arrow()
                    self.state = 1544
                    self.expression()
                    self.state = 1545
                    self.match(CSharpParser.SEMICOLON)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1549
                self.constructor_declaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1550
                self.match(CSharpParser.VOID)
                self.state = 1551
                self.method_declaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1552
                self.class_definition()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1553
                self.struct_definition()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1554
                self.interface_definition()
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1555
                self.enum_definition()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1556
                self.delegate_definition()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Typed_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


        def DOT(self):
            return self.getToken(CSharpParser.DOT, 0)

        def indexer_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Indexer_declarationContext,0)


        def method_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Method_declarationContext,0)


        def property_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Property_declarationContext,0)


        def operator_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Operator_declarationContext,0)


        def field_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Field_declarationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_typed_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTyped_member_declaration" ):
                listener.enterTyped_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTyped_member_declaration" ):
                listener.exitTyped_member_declaration(self)




    def typed_member_declaration(self):

        localctx = CSharpParser.Typed_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 230, self.RULE_typed_member_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            self.cstype()
            self.state = 1569
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
            if la_ == 1:
                self.state = 1560
                self.namespace_or_type_name()
                self.state = 1561
                self.match(CSharpParser.DOT)
                self.state = 1562
                self.indexer_declaration()
                pass

            elif la_ == 2:
                self.state = 1564
                self.method_declaration()
                pass

            elif la_ == 3:
                self.state = 1565
                self.property_declaration()
                pass

            elif la_ == 4:
                self.state = 1566
                self.indexer_declaration()
                pass

            elif la_ == 5:
                self.state = 1567
                self.operator_declaration()
                pass

            elif la_ == 6:
                self.state = 1568
                self.field_declaration()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constant_declaratorsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constant_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Constant_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Constant_declaratorContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_constant_declarators

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstant_declarators" ):
                listener.enterConstant_declarators(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstant_declarators" ):
                listener.exitConstant_declarators(self)




    def constant_declarators(self):

        localctx = CSharpParser.Constant_declaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 232, self.RULE_constant_declarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1571
            self.constant_declarator()
            self.state = 1576
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1572
                self.match(CSharpParser.COMMA)
                self.state = 1573
                self.constant_declarator()
                self.state = 1578
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constant_declaratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_constant_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstant_declarator" ):
                listener.enterConstant_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstant_declarator" ):
                listener.exitConstant_declarator(self)




    def constant_declarator(self):

        localctx = CSharpParser.Constant_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 234, self.RULE_constant_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1579
            self.identifier()
            self.state = 1580
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 1581
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variable_declaratorsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variable_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Variable_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Variable_declaratorContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_variable_declarators

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariable_declarators" ):
                listener.enterVariable_declarators(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariable_declarators" ):
                listener.exitVariable_declarators(self)




    def variable_declarators(self):

        localctx = CSharpParser.Variable_declaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 236, self.RULE_variable_declarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1583
            self.variable_declarator()
            self.state = 1588
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1584
                self.match(CSharpParser.COMMA)
                self.state = 1585
                self.variable_declarator()
                self.state = 1590
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variable_declaratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def variable_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_variable_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariable_declarator" ):
                listener.enterVariable_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariable_declarator" ):
                listener.exitVariable_declarator(self)




    def variable_declarator(self):

        localctx = CSharpParser.Variable_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 238, self.RULE_variable_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1591
            self.identifier()
            self.state = 1594
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 1592
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1593
                self.variable_initializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variable_initializerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def array_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_variable_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariable_initializer" ):
                listener.enterVariable_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariable_initializer" ):
                listener.exitVariable_initializer(self)




    def variable_initializer(self):

        localctx = CSharpParser.Variable_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 240, self.RULE_variable_initializer)
        try:
            self.state = 1598
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1596
                self.expression()
                pass
            elif token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1597
                self.array_initializer()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_typeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_return_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReturn_type" ):
                listener.enterReturn_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReturn_type" ):
                listener.exitReturn_type(self)




    def return_type(self):

        localctx = CSharpParser.Return_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 242, self.RULE_return_type)
        try:
            self.state = 1602
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,171,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1600
                self.cstype()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1601
                self.match(CSharpParser.VOID)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Member_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_member_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMember_name" ):
                listener.enterMember_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMember_name" ):
                listener.exitMember_name(self)




    def member_name(self):

        localctx = CSharpParser.Member_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 244, self.RULE_member_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1604
            self.namespace_or_type_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Method_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_method_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_body" ):
                listener.enterMethod_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_body" ):
                listener.exitMethod_body(self)




    def method_body(self):

        localctx = CSharpParser.Method_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 246, self.RULE_method_body)
        try:
            self.state = 1608
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1606
                self.block()
                pass
            elif token in [CSharpParser.SEMICOLON]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1607
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Formal_parameter_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def parameter_array(self):
            return self.getTypedRuleContext(CSharpParser.Parameter_arrayContext,0)


        def fixed_parameters(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_parametersContext,0)


        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_formal_parameter_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFormal_parameter_list" ):
                listener.enterFormal_parameter_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFormal_parameter_list" ):
                listener.exitFormal_parameter_list(self)




    def formal_parameter_list(self):

        localctx = CSharpParser.Formal_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 248, self.RULE_formal_parameter_list)
        self._la = 0 # Token type
        try:
            self.state = 1616
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1610
                self.parameter_array()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1611
                self.fixed_parameters()
                self.state = 1614
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1612
                    self.match(CSharpParser.COMMA)
                    self.state = 1613
                    self.parameter_array()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_parametersContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fixed_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Fixed_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Fixed_parameterContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_parameters

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_parameters" ):
                listener.enterFixed_parameters(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_parameters" ):
                listener.exitFixed_parameters(self)




    def fixed_parameters(self):

        localctx = CSharpParser.Fixed_parametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 250, self.RULE_fixed_parameters)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1618
            self.fixed_parameter()
            self.state = 1623
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,175,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1619
                    self.match(CSharpParser.COMMA)
                    self.state = 1620
                    self.fixed_parameter() 
                self.state = 1625
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,175,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_parameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def arg_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def parameter_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Parameter_modifierContext,0)


        def ARGLIST(self):
            return self.getToken(CSharpParser.ARGLIST, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_parameter" ):
                listener.enterFixed_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_parameter" ):
                listener.exitFixed_parameter(self)




    def fixed_parameter(self):

        localctx = CSharpParser.Fixed_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 252, self.RULE_fixed_parameter)
        self._la = 0 # Token type
        try:
            self.state = 1634
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,178,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1627
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.OPEN_BRACKET:
                    self.state = 1626
                    self.attributes()


                self.state = 1630
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CSharpParser.OUT - 71)) | (1 << (CSharpParser.REF - 71)) | (1 << (CSharpParser.THIS - 71)))) != 0):
                    self.state = 1629
                    self.parameter_modifier()


                self.state = 1632
                self.arg_declaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1633
                self.match(CSharpParser.ARGLIST)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Parameter_modifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_parameter_modifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameter_modifier" ):
                listener.enterParameter_modifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameter_modifier" ):
                listener.exitParameter_modifier(self)




    def parameter_modifier(self):

        localctx = CSharpParser.Parameter_modifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 254, self.RULE_parameter_modifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1636
            _la = self._input.LA(1)
            if not(((((_la - 71)) & ~0x3f) == 0 and ((1 << (_la - 71)) & ((1 << (CSharpParser.OUT - 71)) | (1 << (CSharpParser.REF - 71)) | (1 << (CSharpParser.THIS - 71)))) != 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 Parameter_arrayContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PARAMS(self):
            return self.getToken(CSharpParser.PARAMS, 0)

        def array_type(self):
            return self.getTypedRuleContext(CSharpParser.Array_typeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_parameter_array

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParameter_array" ):
                listener.enterParameter_array(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParameter_array" ):
                listener.exitParameter_array(self)




    def parameter_array(self):

        localctx = CSharpParser.Parameter_arrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 256, self.RULE_parameter_array)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1639
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1638
                self.attributes()


            self.state = 1641
            self.match(CSharpParser.PARAMS)
            self.state = 1642
            self.array_type()
            self.state = 1643
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Accessor_declarationsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.attrs = None # AttributesContext
            self.mods = None # Accessor_modifierContext

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def accessor_body(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)


        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def accessor_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)


        def set_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Set_accessor_declarationContext,0)


        def get_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Get_accessor_declarationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_accessor_declarations

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAccessor_declarations" ):
                listener.enterAccessor_declarations(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAccessor_declarations" ):
                listener.exitAccessor_declarations(self)




    def accessor_declarations(self):

        localctx = CSharpParser.Accessor_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 258, self.RULE_accessor_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1646
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1645
                localctx.attrs = self.attributes()


            self.state = 1649
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & ((1 << (CSharpParser.INTERNAL - 56)) | (1 << (CSharpParser.PRIVATE - 56)) | (1 << (CSharpParser.PROTECTED - 56)))) != 0):
                self.state = 1648
                localctx.mods = self.accessor_modifier()


            self.state = 1661
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.GET]:
                self.state = 1651
                self.match(CSharpParser.GET)
                self.state = 1652
                self.accessor_body()
                self.state = 1654
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.INTERNAL or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CSharpParser.PRIVATE - 75)) | (1 << (CSharpParser.PROTECTED - 75)) | (1 << (CSharpParser.SET - 75)) | (1 << (CSharpParser.OPEN_BRACKET - 75)))) != 0):
                    self.state = 1653
                    self.set_accessor_declaration()


                pass
            elif token in [CSharpParser.SET]:
                self.state = 1656
                self.match(CSharpParser.SET)
                self.state = 1657
                self.accessor_body()
                self.state = 1659
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.GET or _la==CSharpParser.INTERNAL or ((((_la - 75)) & ~0x3f) == 0 and ((1 << (_la - 75)) & ((1 << (CSharpParser.PRIVATE - 75)) | (1 << (CSharpParser.PROTECTED - 75)) | (1 << (CSharpParser.OPEN_BRACKET - 75)))) != 0):
                    self.state = 1658
                    self.get_accessor_declaration()


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Get_accessor_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def accessor_body(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def accessor_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_get_accessor_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGet_accessor_declaration" ):
                listener.enterGet_accessor_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGet_accessor_declaration" ):
                listener.exitGet_accessor_declaration(self)




    def get_accessor_declaration(self):

        localctx = CSharpParser.Get_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 260, self.RULE_get_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1664
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1663
                self.attributes()


            self.state = 1667
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & ((1 << (CSharpParser.INTERNAL - 56)) | (1 << (CSharpParser.PRIVATE - 56)) | (1 << (CSharpParser.PROTECTED - 56)))) != 0):
                self.state = 1666
                self.accessor_modifier()


            self.state = 1669
            self.match(CSharpParser.GET)
            self.state = 1670
            self.accessor_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Set_accessor_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def accessor_body(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def accessor_modifier(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_set_accessor_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSet_accessor_declaration" ):
                listener.enterSet_accessor_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSet_accessor_declaration" ):
                listener.exitSet_accessor_declaration(self)




    def set_accessor_declaration(self):

        localctx = CSharpParser.Set_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 262, self.RULE_set_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1673
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1672
                self.attributes()


            self.state = 1676
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 56)) & ~0x3f) == 0 and ((1 << (_la - 56)) & ((1 << (CSharpParser.INTERNAL - 56)) | (1 << (CSharpParser.PRIVATE - 56)) | (1 << (CSharpParser.PROTECTED - 56)))) != 0):
                self.state = 1675
                self.accessor_modifier()


            self.state = 1678
            self.match(CSharpParser.SET)
            self.state = 1679
            self.accessor_body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Accessor_modifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PROTECTED(self):
            return self.getToken(CSharpParser.PROTECTED, 0)

        def INTERNAL(self):
            return self.getToken(CSharpParser.INTERNAL, 0)

        def PRIVATE(self):
            return self.getToken(CSharpParser.PRIVATE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_accessor_modifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAccessor_modifier" ):
                listener.enterAccessor_modifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAccessor_modifier" ):
                listener.exitAccessor_modifier(self)




    def accessor_modifier(self):

        localctx = CSharpParser.Accessor_modifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 264, self.RULE_accessor_modifier)
        try:
            self.state = 1688
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,189,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1681
                self.match(CSharpParser.PROTECTED)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1682
                self.match(CSharpParser.INTERNAL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1683
                self.match(CSharpParser.PRIVATE)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1684
                self.match(CSharpParser.PROTECTED)
                self.state = 1685
                self.match(CSharpParser.INTERNAL)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1686
                self.match(CSharpParser.INTERNAL)
                self.state = 1687
                self.match(CSharpParser.PROTECTED)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Accessor_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_accessor_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAccessor_body" ):
                listener.enterAccessor_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAccessor_body" ):
                listener.exitAccessor_body(self)




    def accessor_body(self):

        localctx = CSharpParser.Accessor_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 266, self.RULE_accessor_body)
        try:
            self.state = 1692
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1690
                self.block()
                pass
            elif token in [CSharpParser.SEMICOLON]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1691
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Event_accessor_declarationsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ADD(self):
            return self.getToken(CSharpParser.ADD, 0)

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def remove_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Remove_accessor_declarationContext,0)


        def REMOVE(self):
            return self.getToken(CSharpParser.REMOVE, 0)

        def add_accessor_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Add_accessor_declarationContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_event_accessor_declarations

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEvent_accessor_declarations" ):
                listener.enterEvent_accessor_declarations(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEvent_accessor_declarations" ):
                listener.exitEvent_accessor_declarations(self)




    def event_accessor_declarations(self):

        localctx = CSharpParser.Event_accessor_declarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 268, self.RULE_event_accessor_declarations)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1695
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1694
                self.attributes()


            self.state = 1705
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD]:
                self.state = 1697
                self.match(CSharpParser.ADD)
                self.state = 1698
                self.block()
                self.state = 1699
                self.remove_accessor_declaration()
                pass
            elif token in [CSharpParser.REMOVE]:
                self.state = 1701
                self.match(CSharpParser.REMOVE)
                self.state = 1702
                self.block()
                self.state = 1703
                self.add_accessor_declaration()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Add_accessor_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ADD(self):
            return self.getToken(CSharpParser.ADD, 0)

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_add_accessor_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAdd_accessor_declaration" ):
                listener.enterAdd_accessor_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAdd_accessor_declaration" ):
                listener.exitAdd_accessor_declaration(self)




    def add_accessor_declaration(self):

        localctx = CSharpParser.Add_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 270, self.RULE_add_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1708
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1707
                self.attributes()


            self.state = 1710
            self.match(CSharpParser.ADD)
            self.state = 1711
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Remove_accessor_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REMOVE(self):
            return self.getToken(CSharpParser.REMOVE, 0)

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_remove_accessor_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRemove_accessor_declaration" ):
                listener.enterRemove_accessor_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRemove_accessor_declaration" ):
                listener.exitRemove_accessor_declaration(self)




    def remove_accessor_declaration(self):

        localctx = CSharpParser.Remove_accessor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 272, self.RULE_remove_accessor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1714
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1713
                self.attributes()


            self.state = 1716
            self.match(CSharpParser.REMOVE)
            self.state = 1717
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Overloadable_operatorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PLUS(self):
            return self.getToken(CSharpParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(CSharpParser.MINUS, 0)

        def BANG(self):
            return self.getToken(CSharpParser.BANG, 0)

        def TILDE(self):
            return self.getToken(CSharpParser.TILDE, 0)

        def OP_INC(self):
            return self.getToken(CSharpParser.OP_INC, 0)

        def OP_DEC(self):
            return self.getToken(CSharpParser.OP_DEC, 0)

        def TRUE(self):
            return self.getToken(CSharpParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(CSharpParser.FALSE, 0)

        def STAR(self):
            return self.getToken(CSharpParser.STAR, 0)

        def DIV(self):
            return self.getToken(CSharpParser.DIV, 0)

        def PERCENT(self):
            return self.getToken(CSharpParser.PERCENT, 0)

        def AMP(self):
            return self.getToken(CSharpParser.AMP, 0)

        def BITWISE_OR(self):
            return self.getToken(CSharpParser.BITWISE_OR, 0)

        def CARET(self):
            return self.getToken(CSharpParser.CARET, 0)

        def OP_LEFT_SHIFT(self):
            return self.getToken(CSharpParser.OP_LEFT_SHIFT, 0)

        def right_shift(self):
            return self.getTypedRuleContext(CSharpParser.Right_shiftContext,0)


        def OP_EQ(self):
            return self.getToken(CSharpParser.OP_EQ, 0)

        def OP_NE(self):
            return self.getToken(CSharpParser.OP_NE, 0)

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def OP_GE(self):
            return self.getToken(CSharpParser.OP_GE, 0)

        def OP_LE(self):
            return self.getToken(CSharpParser.OP_LE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_overloadable_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOverloadable_operator" ):
                listener.enterOverloadable_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOverloadable_operator" ):
                listener.exitOverloadable_operator(self)




    def overloadable_operator(self):

        localctx = CSharpParser.Overloadable_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 274, self.RULE_overloadable_operator)
        try:
            self.state = 1741
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1719
                self.match(CSharpParser.PLUS)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1720
                self.match(CSharpParser.MINUS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1721
                self.match(CSharpParser.BANG)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1722
                self.match(CSharpParser.TILDE)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1723
                self.match(CSharpParser.OP_INC)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1724
                self.match(CSharpParser.OP_DEC)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1725
                self.match(CSharpParser.TRUE)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1726
                self.match(CSharpParser.FALSE)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1727
                self.match(CSharpParser.STAR)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1728
                self.match(CSharpParser.DIV)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1729
                self.match(CSharpParser.PERCENT)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1730
                self.match(CSharpParser.AMP)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1731
                self.match(CSharpParser.BITWISE_OR)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1732
                self.match(CSharpParser.CARET)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 1733
                self.match(CSharpParser.OP_LEFT_SHIFT)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 1734
                self.right_shift()
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 1735
                self.match(CSharpParser.OP_EQ)
                pass

            elif la_ == 18:
                self.enterOuterAlt(localctx, 18)
                self.state = 1736
                self.match(CSharpParser.OP_NE)
                pass

            elif la_ == 19:
                self.enterOuterAlt(localctx, 19)
                self.state = 1737
                self.match(CSharpParser.GT)
                pass

            elif la_ == 20:
                self.enterOuterAlt(localctx, 20)
                self.state = 1738
                self.match(CSharpParser.LT)
                pass

            elif la_ == 21:
                self.enterOuterAlt(localctx, 21)
                self.state = 1739
                self.match(CSharpParser.OP_GE)
                pass

            elif la_ == 22:
                self.enterOuterAlt(localctx, 22)
                self.state = 1740
                self.match(CSharpParser.OP_LE)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Conversion_operator_declaratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPERATOR(self):
            return self.getToken(CSharpParser.OPERATOR, 0)

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def arg_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,0)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def IMPLICIT(self):
            return self.getToken(CSharpParser.IMPLICIT, 0)

        def EXPLICIT(self):
            return self.getToken(CSharpParser.EXPLICIT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_conversion_operator_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConversion_operator_declarator" ):
                listener.enterConversion_operator_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConversion_operator_declarator" ):
                listener.exitConversion_operator_declarator(self)




    def conversion_operator_declarator(self):

        localctx = CSharpParser.Conversion_operator_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 276, self.RULE_conversion_operator_declarator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1743
            _la = self._input.LA(1)
            if not(_la==CSharpParser.EXPLICIT or _la==CSharpParser.IMPLICIT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1744
            self.match(CSharpParser.OPERATOR)
            self.state = 1745
            self.cstype()
            self.state = 1746
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1747
            self.arg_declaration()
            self.state = 1748
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constructor_initializerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def BASE(self):
            return self.getToken(CSharpParser.BASE, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_constructor_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructor_initializer" ):
                listener.enterConstructor_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructor_initializer" ):
                listener.exitConstructor_initializer(self)




    def constructor_initializer(self):

        localctx = CSharpParser.Constructor_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 278, self.RULE_constructor_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1750
            self.match(CSharpParser.COLON)
            self.state = 1751
            _la = self._input.LA(1)
            if not(_la==CSharpParser.BASE or _la==CSharpParser.THIS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 1752
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 1754
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.OUT - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)))) != 0):
                self.state = 1753
                self.argument_list()


            self.state = 1756
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def block(self):
            return self.getTypedRuleContext(CSharpParser.BlockContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBody" ):
                listener.enterBody(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBody" ):
                listener.exitBody(self)




    def body(self):

        localctx = CSharpParser.BodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 280, self.RULE_body)
        try:
            self.state = 1760
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1758
                self.block()
                pass
            elif token in [CSharpParser.SEMICOLON]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1759
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_interfacesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def interface_type_list(self):
            return self.getTypedRuleContext(CSharpParser.Interface_type_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_struct_interfaces

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStruct_interfaces" ):
                listener.enterStruct_interfaces(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStruct_interfaces" ):
                listener.exitStruct_interfaces(self)




    def struct_interfaces(self):

        localctx = CSharpParser.Struct_interfacesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 282, self.RULE_struct_interfaces)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1762
            self.match(CSharpParser.COLON)
            self.state = 1763
            self.interface_type_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def struct_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Struct_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Struct_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_struct_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStruct_body" ):
                listener.enterStruct_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStruct_body" ):
                listener.exitStruct_body(self)




    def struct_body(self):

        localctx = CSharpParser.Struct_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 284, self.RULE_struct_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1765
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1769
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FIXED) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.OVERRIDE - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.PRIVATE - 65)) | (1 << (CSharpParser.PROTECTED - 65)) | (1 << (CSharpParser.PUBLIC - 65)) | (1 << (CSharpParser.READONLY - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SEALED - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.STATIC - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.STRUCT - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VIRTUAL - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.VOLATILE - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 0):
                self.state = 1766
                self.struct_member_declaration()
                self.state = 1771
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1772
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def common_member_declaration(self):
            return self.getTypedRuleContext(CSharpParser.Common_member_declarationContext,0)


        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def all_member_modifiers(self):
            return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)


        def fixed_size_buffer_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Fixed_size_buffer_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Fixed_size_buffer_declaratorContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_struct_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStruct_member_declaration" ):
                listener.enterStruct_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStruct_member_declaration" ):
                listener.exitStruct_member_declaration(self)




    def struct_member_declaration(self):

        localctx = CSharpParser.Struct_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 286, self.RULE_struct_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1775
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1774
                self.attributes()


            self.state = 1778
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,200,self._ctx)
            if la_ == 1:
                self.state = 1777
                self.all_member_modifiers()


            self.state = 1790
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.state = 1780
                self.common_member_declaration()
                pass
            elif token in [CSharpParser.FIXED]:
                self.state = 1781
                self.match(CSharpParser.FIXED)
                self.state = 1782
                self.cstype()
                self.state = 1784 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1783
                    self.fixed_size_buffer_declarator()
                    self.state = 1786 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CSharpParser.ON - 68)) | (1 << (CSharpParser.ORDERBY - 68)) | (1 << (CSharpParser.PARTIAL - 68)) | (1 << (CSharpParser.REMOVE - 68)) | (1 << (CSharpParser.SELECT - 68)) | (1 << (CSharpParser.SET - 68)) | (1 << (CSharpParser.VAR - 68)) | (1 << (CSharpParser.WHEN - 68)) | (1 << (CSharpParser.WHERE - 68)) | (1 << (CSharpParser.YIELD - 68)) | (1 << (CSharpParser.IDENTIFIER - 68)))) != 0)):
                        break

                self.state = 1788
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Array_typeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def base_type(self):
            return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)


        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)


        def STAR(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.STAR)
            else:
                return self.getToken(CSharpParser.STAR, i)

        def INTERR(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.INTERR)
            else:
                return self.getToken(CSharpParser.INTERR, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_array_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArray_type" ):
                listener.enterArray_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArray_type" ):
                listener.exitArray_type(self)




    def array_type(self):

        localctx = CSharpParser.Array_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 288, self.RULE_array_type)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1792
            self.base_type()
            self.state = 1800 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1796
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.STAR or _la==CSharpParser.INTERR:
                    self.state = 1793
                    _la = self._input.LA(1)
                    if not(_la==CSharpParser.STAR or _la==CSharpParser.INTERR):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1798
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1799
                self.rank_specifier()
                self.state = 1802 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 124)) & ~0x3f) == 0 and ((1 << (_la - 124)) & ((1 << (CSharpParser.OPEN_BRACKET - 124)) | (1 << (CSharpParser.STAR - 124)) | (1 << (CSharpParser.INTERR - 124)))) != 0)):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Rank_specifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_rank_specifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRank_specifier" ):
                listener.enterRank_specifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRank_specifier" ):
                listener.exitRank_specifier(self)




    def rank_specifier(self):

        localctx = CSharpParser.Rank_specifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 290, self.RULE_rank_specifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1804
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 1808
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1805
                self.match(CSharpParser.COMMA)
                self.state = 1810
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1811
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Array_initializerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def variable_initializer(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Variable_initializerContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_array_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArray_initializer" ):
                listener.enterArray_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArray_initializer" ):
                listener.exitArray_initializer(self)




    def array_initializer(self):

        localctx = CSharpParser.Array_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 292, self.RULE_array_initializer)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1813
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1825
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_BRACE - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)))) != 0):
                self.state = 1814
                self.variable_initializer()
                self.state = 1819
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,206,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1815
                        self.match(CSharpParser.COMMA)
                        self.state = 1816
                        self.variable_initializer() 
                    self.state = 1821
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,206,self._ctx)

                self.state = 1823
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1822
                    self.match(CSharpParser.COMMA)




            self.state = 1827
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variant_type_parameter_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(CSharpParser.LT, 0)

        def variant_type_parameter(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Variant_type_parameterContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Variant_type_parameterContext,i)


        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_variant_type_parameter_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariant_type_parameter_list" ):
                listener.enterVariant_type_parameter_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariant_type_parameter_list" ):
                listener.exitVariant_type_parameter_list(self)




    def variant_type_parameter_list(self):

        localctx = CSharpParser.Variant_type_parameter_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 294, self.RULE_variant_type_parameter_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1829
            self.match(CSharpParser.LT)
            self.state = 1830
            self.variant_type_parameter()
            self.state = 1835
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 1831
                self.match(CSharpParser.COMMA)
                self.state = 1832
                self.variant_type_parameter()
                self.state = 1837
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1838
            self.match(CSharpParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variant_type_parameterContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def variance_annotation(self):
            return self.getTypedRuleContext(CSharpParser.Variance_annotationContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_variant_type_parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariant_type_parameter" ):
                listener.enterVariant_type_parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariant_type_parameter" ):
                listener.exitVariant_type_parameter(self)




    def variant_type_parameter(self):

        localctx = CSharpParser.Variant_type_parameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 296, self.RULE_variant_type_parameter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1841
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1840
                self.attributes()


            self.state = 1844
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.IN or _la==CSharpParser.OUT:
                self.state = 1843
                self.variance_annotation()


            self.state = 1846
            self.identifier()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Variance_annotationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IN(self):
            return self.getToken(CSharpParser.IN, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_variance_annotation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariance_annotation" ):
                listener.enterVariance_annotation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariance_annotation" ):
                listener.exitVariance_annotation(self)




    def variance_annotation(self):

        localctx = CSharpParser.Variance_annotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 298, self.RULE_variance_annotation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1848
            _la = self._input.LA(1)
            if not(_la==CSharpParser.IN or _la==CSharpParser.OUT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_baseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def interface_type_list(self):
            return self.getTypedRuleContext(CSharpParser.Interface_type_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_base

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_base" ):
                listener.enterInterface_base(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_base" ):
                listener.exitInterface_base(self)




    def interface_base(self):

        localctx = CSharpParser.Interface_baseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 300, self.RULE_interface_base)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1850
            self.match(CSharpParser.COLON)
            self.state = 1851
            self.interface_type_list()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def interface_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Interface_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Interface_member_declarationContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_body" ):
                listener.enterInterface_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_body" ):
                listener.exitInterface_body(self)




    def interface_body(self):

        localctx = CSharpParser.Interface_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 302, self.RULE_interface_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1853
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1857
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNSAFE - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.OPEN_BRACKET - 65)))) != 0):
                self.state = 1854
                self.interface_member_declaration()
                self.state = 1859
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1860
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def EVENT(self):
            return self.getToken(CSharpParser.EVENT, 0)

        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def interface_accessors(self):
            return self.getTypedRuleContext(CSharpParser.Interface_accessorsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_member_declaration" ):
                listener.enterInterface_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_member_declaration" ):
                listener.exitInterface_member_declaration(self)




    def interface_member_declaration(self):

        localctx = CSharpParser.Interface_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 304, self.RULE_interface_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1863
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1862
                self.attributes()


            self.state = 1866
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.NEW:
                self.state = 1865
                self.match(CSharpParser.NEW)


            self.state = 1924
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,224,self._ctx)
            if la_ == 1:
                self.state = 1869
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.UNSAFE:
                    self.state = 1868
                    self.match(CSharpParser.UNSAFE)


                self.state = 1871
                self.cstype()
                self.state = 1899
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,219,self._ctx)
                if la_ == 1:
                    self.state = 1872
                    self.identifier()
                    self.state = 1874
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.LT:
                        self.state = 1873
                        self.type_parameter_list()


                    self.state = 1876
                    self.match(CSharpParser.OPEN_PARENS)
                    self.state = 1878
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CSharpParser.OBJECT - 67)) | (1 << (CSharpParser.ON - 67)) | (1 << (CSharpParser.ORDERBY - 67)) | (1 << (CSharpParser.OUT - 67)) | (1 << (CSharpParser.PARAMS - 67)) | (1 << (CSharpParser.PARTIAL - 67)) | (1 << (CSharpParser.REF - 67)) | (1 << (CSharpParser.REMOVE - 67)) | (1 << (CSharpParser.SBYTE - 67)) | (1 << (CSharpParser.SELECT - 67)) | (1 << (CSharpParser.SET - 67)) | (1 << (CSharpParser.SHORT - 67)) | (1 << (CSharpParser.STRING - 67)) | (1 << (CSharpParser.THIS - 67)) | (1 << (CSharpParser.UINT - 67)) | (1 << (CSharpParser.ULONG - 67)) | (1 << (CSharpParser.USHORT - 67)) | (1 << (CSharpParser.VAR - 67)) | (1 << (CSharpParser.VOID - 67)) | (1 << (CSharpParser.WHEN - 67)) | (1 << (CSharpParser.WHERE - 67)) | (1 << (CSharpParser.YIELD - 67)) | (1 << (CSharpParser.IDENTIFIER - 67)) | (1 << (CSharpParser.OPEN_BRACKET - 67)))) != 0):
                        self.state = 1877
                        self.formal_parameter_list()


                    self.state = 1880
                    self.match(CSharpParser.CLOSE_PARENS)
                    self.state = 1882
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.WHERE:
                        self.state = 1881
                        self.type_parameter_constraints_clauses()


                    self.state = 1884
                    self.match(CSharpParser.SEMICOLON)
                    pass

                elif la_ == 2:
                    self.state = 1886
                    self.identifier()
                    self.state = 1887
                    self.match(CSharpParser.OPEN_BRACE)
                    self.state = 1888
                    self.interface_accessors()
                    self.state = 1889
                    self.match(CSharpParser.CLOSE_BRACE)
                    pass

                elif la_ == 3:
                    self.state = 1891
                    self.match(CSharpParser.THIS)
                    self.state = 1892
                    self.match(CSharpParser.OPEN_BRACKET)
                    self.state = 1893
                    self.formal_parameter_list()
                    self.state = 1894
                    self.match(CSharpParser.CLOSE_BRACKET)
                    self.state = 1895
                    self.match(CSharpParser.OPEN_BRACE)
                    self.state = 1896
                    self.interface_accessors()
                    self.state = 1897
                    self.match(CSharpParser.CLOSE_BRACE)
                    pass


                pass

            elif la_ == 2:
                self.state = 1902
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.UNSAFE:
                    self.state = 1901
                    self.match(CSharpParser.UNSAFE)


                self.state = 1904
                self.match(CSharpParser.VOID)
                self.state = 1905
                self.identifier()
                self.state = 1907
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.LT:
                    self.state = 1906
                    self.type_parameter_list()


                self.state = 1909
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 1911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CSharpParser.OBJECT - 67)) | (1 << (CSharpParser.ON - 67)) | (1 << (CSharpParser.ORDERBY - 67)) | (1 << (CSharpParser.OUT - 67)) | (1 << (CSharpParser.PARAMS - 67)) | (1 << (CSharpParser.PARTIAL - 67)) | (1 << (CSharpParser.REF - 67)) | (1 << (CSharpParser.REMOVE - 67)) | (1 << (CSharpParser.SBYTE - 67)) | (1 << (CSharpParser.SELECT - 67)) | (1 << (CSharpParser.SET - 67)) | (1 << (CSharpParser.SHORT - 67)) | (1 << (CSharpParser.STRING - 67)) | (1 << (CSharpParser.THIS - 67)) | (1 << (CSharpParser.UINT - 67)) | (1 << (CSharpParser.ULONG - 67)) | (1 << (CSharpParser.USHORT - 67)) | (1 << (CSharpParser.VAR - 67)) | (1 << (CSharpParser.VOID - 67)) | (1 << (CSharpParser.WHEN - 67)) | (1 << (CSharpParser.WHERE - 67)) | (1 << (CSharpParser.YIELD - 67)) | (1 << (CSharpParser.IDENTIFIER - 67)) | (1 << (CSharpParser.OPEN_BRACKET - 67)))) != 0):
                    self.state = 1910
                    self.formal_parameter_list()


                self.state = 1913
                self.match(CSharpParser.CLOSE_PARENS)
                self.state = 1915
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.WHERE:
                    self.state = 1914
                    self.type_parameter_constraints_clauses()


                self.state = 1917
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 3:
                self.state = 1919
                self.match(CSharpParser.EVENT)
                self.state = 1920
                self.cstype()
                self.state = 1921
                self.identifier()
                self.state = 1922
                self.match(CSharpParser.SEMICOLON)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_accessorsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def SEMICOLON(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.SEMICOLON)
            else:
                return self.getToken(CSharpParser.SEMICOLON, i)

        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def attributes(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.AttributesContext)
            else:
                return self.getTypedRuleContext(CSharpParser.AttributesContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interface_accessors

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_accessors" ):
                listener.enterInterface_accessors(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_accessors" ):
                listener.exitInterface_accessors(self)




    def interface_accessors(self):

        localctx = CSharpParser.Interface_accessorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 306, self.RULE_interface_accessors)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1927
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1926
                self.attributes()


            self.state = 1947
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.GET]:
                self.state = 1929
                self.match(CSharpParser.GET)
                self.state = 1930
                self.match(CSharpParser.SEMICOLON)
                self.state = 1936
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.SET or _la==CSharpParser.OPEN_BRACKET:
                    self.state = 1932
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.OPEN_BRACKET:
                        self.state = 1931
                        self.attributes()


                    self.state = 1934
                    self.match(CSharpParser.SET)
                    self.state = 1935
                    self.match(CSharpParser.SEMICOLON)


                pass
            elif token in [CSharpParser.SET]:
                self.state = 1938
                self.match(CSharpParser.SET)
                self.state = 1939
                self.match(CSharpParser.SEMICOLON)
                self.state = 1945
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.GET or _la==CSharpParser.OPEN_BRACKET:
                    self.state = 1941
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.OPEN_BRACKET:
                        self.state = 1940
                        self.attributes()


                    self.state = 1943
                    self.match(CSharpParser.GET)
                    self.state = 1944
                    self.match(CSharpParser.SEMICOLON)


                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_baseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_enum_base

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_base" ):
                listener.enterEnum_base(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_base" ):
                listener.exitEnum_base(self)




    def enum_base(self):

        localctx = CSharpParser.Enum_baseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 308, self.RULE_enum_base)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1949
            self.match(CSharpParser.COLON)
            self.state = 1950
            self.cstype()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_bodyContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def enum_member_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Enum_member_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Enum_member_declarationContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_enum_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_body" ):
                listener.enterEnum_body(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_body" ):
                listener.exitEnum_body(self)




    def enum_body(self):

        localctx = CSharpParser.Enum_bodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 310, self.RULE_enum_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1952
            self.match(CSharpParser.OPEN_BRACE)
            self.state = 1964
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CSharpParser.ON - 68)) | (1 << (CSharpParser.ORDERBY - 68)) | (1 << (CSharpParser.PARTIAL - 68)) | (1 << (CSharpParser.REMOVE - 68)) | (1 << (CSharpParser.SELECT - 68)) | (1 << (CSharpParser.SET - 68)) | (1 << (CSharpParser.VAR - 68)) | (1 << (CSharpParser.WHEN - 68)) | (1 << (CSharpParser.WHERE - 68)) | (1 << (CSharpParser.YIELD - 68)) | (1 << (CSharpParser.IDENTIFIER - 68)) | (1 << (CSharpParser.OPEN_BRACKET - 68)))) != 0):
                self.state = 1953
                self.enum_member_declaration()
                self.state = 1958
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,231,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 1954
                        self.match(CSharpParser.COMMA)
                        self.state = 1955
                        self.enum_member_declaration() 
                    self.state = 1960
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,231,self._ctx)

                self.state = 1962
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.COMMA:
                    self.state = 1961
                    self.match(CSharpParser.COMMA)




            self.state = 1966
            self.match(CSharpParser.CLOSE_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_member_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def attributes(self):
            return self.getTypedRuleContext(CSharpParser.AttributesContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_enum_member_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_member_declaration" ):
                listener.enterEnum_member_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_member_declaration" ):
                listener.exitEnum_member_declaration(self)




    def enum_member_declaration(self):

        localctx = CSharpParser.Enum_member_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 312, self.RULE_enum_member_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1969
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACKET:
                self.state = 1968
                self.attributes()


            self.state = 1971
            self.identifier()
            self.state = 1974
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 1972
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 1973
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Global_attribute_sectionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def global_attribute_target(self):
            return self.getTypedRuleContext(CSharpParser.Global_attribute_targetContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def attribute_list(self):
            return self.getTypedRuleContext(CSharpParser.Attribute_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_global_attribute_section

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_attribute_section" ):
                listener.enterGlobal_attribute_section(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_attribute_section" ):
                listener.exitGlobal_attribute_section(self)




    def global_attribute_section(self):

        localctx = CSharpParser.Global_attribute_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 314, self.RULE_global_attribute_section)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1976
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 1977
            self.global_attribute_target()
            self.state = 1978
            self.match(CSharpParser.COLON)
            self.state = 1979
            self.attribute_list()
            self.state = 1981
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 1980
                self.match(CSharpParser.COMMA)


            self.state = 1983
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Global_attribute_targetContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def keyword(self):
            return self.getTypedRuleContext(CSharpParser.KeywordContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_global_attribute_target

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGlobal_attribute_target" ):
                listener.enterGlobal_attribute_target(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGlobal_attribute_target" ):
                listener.exitGlobal_attribute_target(self)




    def global_attribute_target(self):

        localctx = CSharpParser.Global_attribute_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 316, self.RULE_global_attribute_target)
        try:
            self.state = 1987
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ABSTRACT, CSharpParser.AS, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BYTE, CSharpParser.CASE, CSharpParser.CATCH, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.ELSE, CSharpParser.ENUM, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.EXTERN, CSharpParser.FALSE, CSharpParser.FINALLY, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.GOTO, CSharpParser.IF, CSharpParser.IMPLICIT, CSharpParser.IN, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTERNAL, CSharpParser.IS, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMESPACE, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.OPERATOR, CSharpParser.OUT, CSharpParser.OVERRIDE, CSharpParser.PARAMS, CSharpParser.PRIVATE, CSharpParser.PROTECTED, CSharpParser.PUBLIC, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SEALED, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STACKALLOC, CSharpParser.STATIC, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VIRTUAL, CSharpParser.VOID, CSharpParser.VOLATILE, CSharpParser.WHILE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1985
                self.keyword()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1986
                self.identifier()
                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 AttributesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute_section(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Attribute_sectionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Attribute_sectionContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_attributes

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttributes" ):
                listener.enterAttributes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttributes" ):
                listener.exitAttributes(self)




    def attributes(self):

        localctx = CSharpParser.AttributesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 318, self.RULE_attributes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1990 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1989
                self.attribute_section()
                self.state = 1992 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==CSharpParser.OPEN_BRACKET):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_sectionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def attribute_list(self):
            return self.getTypedRuleContext(CSharpParser.Attribute_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def attribute_target(self):
            return self.getTypedRuleContext(CSharpParser.Attribute_targetContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_section

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_section" ):
                listener.enterAttribute_section(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_section" ):
                listener.exitAttribute_section(self)




    def attribute_section(self):

        localctx = CSharpParser.Attribute_sectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 320, self.RULE_attribute_section)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1994
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 1998
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,239,self._ctx)
            if la_ == 1:
                self.state = 1995
                self.attribute_target()
                self.state = 1996
                self.match(CSharpParser.COLON)


            self.state = 2000
            self.attribute_list()
            self.state = 2002
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 2001
                self.match(CSharpParser.COMMA)


            self.state = 2004
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_targetContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def keyword(self):
            return self.getTypedRuleContext(CSharpParser.KeywordContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_target

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_target" ):
                listener.enterAttribute_target(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_target" ):
                listener.exitAttribute_target(self)




    def attribute_target(self):

        localctx = CSharpParser.Attribute_targetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 322, self.RULE_attribute_target)
        try:
            self.state = 2008
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ABSTRACT, CSharpParser.AS, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BYTE, CSharpParser.CASE, CSharpParser.CATCH, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.ELSE, CSharpParser.ENUM, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.EXTERN, CSharpParser.FALSE, CSharpParser.FINALLY, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.GOTO, CSharpParser.IF, CSharpParser.IMPLICIT, CSharpParser.IN, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTERNAL, CSharpParser.IS, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMESPACE, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.OPERATOR, CSharpParser.OUT, CSharpParser.OVERRIDE, CSharpParser.PARAMS, CSharpParser.PRIVATE, CSharpParser.PROTECTED, CSharpParser.PUBLIC, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SEALED, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STACKALLOC, CSharpParser.STATIC, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VIRTUAL, CSharpParser.VOID, CSharpParser.VOLATILE, CSharpParser.WHILE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2006
                self.keyword()
                pass
            elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2007
                self.identifier()
                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 Attribute_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def attribute(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.AttributeContext)
            else:
                return self.getTypedRuleContext(CSharpParser.AttributeContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_list" ):
                listener.enterAttribute_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_list" ):
                listener.exitAttribute_list(self)




    def attribute_list(self):

        localctx = CSharpParser.Attribute_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 324, self.RULE_attribute_list)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2010
            self.attribute()
            self.state = 2015
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,242,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2011
                    self.match(CSharpParser.COMMA)
                    self.state = 2012
                    self.attribute() 
                self.state = 2017
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,242,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AttributeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def namespace_or_type_name(self):
            return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def attribute_argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Attribute_argumentContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Attribute_argumentContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute" ):
                listener.enterAttribute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute" ):
                listener.exitAttribute(self)




    def attribute(self):

        localctx = CSharpParser.AttributeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 326, self.RULE_attribute)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2018
            self.namespace_or_type_name()
            self.state = 2031
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_PARENS:
                self.state = 2019
                self.match(CSharpParser.OPEN_PARENS)
                self.state = 2028
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)))) != 0):
                    self.state = 2020
                    self.attribute_argument()
                    self.state = 2025
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==CSharpParser.COMMA:
                        self.state = 2021
                        self.match(CSharpParser.COMMA)
                        self.state = 2022
                        self.attribute_argument()
                        self.state = 2027
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 2030
                self.match(CSharpParser.CLOSE_PARENS)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attribute_argumentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_attribute_argument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttribute_argument" ):
                listener.enterAttribute_argument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttribute_argument" ):
                listener.exitAttribute_argument(self)




    def attribute_argument(self):

        localctx = CSharpParser.Attribute_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 328, self.RULE_attribute_argument)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2036
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,246,self._ctx)
            if la_ == 1:
                self.state = 2033
                self.identifier()
                self.state = 2034
                self.match(CSharpParser.COLON)


            self.state = 2038
            self.expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pointer_typeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STAR(self):
            return self.getToken(CSharpParser.STAR, 0)

        def simple_type(self):
            return self.getTypedRuleContext(CSharpParser.Simple_typeContext,0)


        def class_type(self):
            return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)


        def rank_specifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)


        def INTERR(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.INTERR)
            else:
                return self.getToken(CSharpParser.INTERR, i)

        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_pointer_type

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPointer_type" ):
                listener.enterPointer_type(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPointer_type" ):
                listener.exitPointer_type(self)




    def pointer_type(self):

        localctx = CSharpParser.Pointer_typeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 330, self.RULE_pointer_type)
        self._la = 0 # Token type
        try:
            self.state = 2055
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2042
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [CSharpParser.BOOL, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:
                    self.state = 2040
                    self.simple_type()
                    pass
                elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:
                    self.state = 2041
                    self.class_type()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 2048
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==CSharpParser.OPEN_BRACKET or _la==CSharpParser.INTERR:
                    self.state = 2046
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [CSharpParser.OPEN_BRACKET]:
                        self.state = 2044
                        self.rank_specifier()
                        pass
                    elif token in [CSharpParser.INTERR]:
                        self.state = 2045
                        self.match(CSharpParser.INTERR)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 2050
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 2051
                self.match(CSharpParser.STAR)
                pass
            elif token in [CSharpParser.VOID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2053
                self.match(CSharpParser.VOID)
                self.state = 2054
                self.match(CSharpParser.STAR)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_pointer_declaratorsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def fixed_pointer_declarator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Fixed_pointer_declaratorContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_pointer_declarators

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_pointer_declarators" ):
                listener.enterFixed_pointer_declarators(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_pointer_declarators" ):
                listener.exitFixed_pointer_declarators(self)




    def fixed_pointer_declarators(self):

        localctx = CSharpParser.Fixed_pointer_declaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 332, self.RULE_fixed_pointer_declarators)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2057
            self.fixed_pointer_declarator()
            self.state = 2062
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 2058
                self.match(CSharpParser.COMMA)
                self.state = 2059
                self.fixed_pointer_declarator()
                self.state = 2064
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_pointer_declaratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def fixed_pointer_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Fixed_pointer_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_pointer_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_pointer_declarator" ):
                listener.enterFixed_pointer_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_pointer_declarator" ):
                listener.exitFixed_pointer_declarator(self)




    def fixed_pointer_declarator(self):

        localctx = CSharpParser.Fixed_pointer_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 334, self.RULE_fixed_pointer_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2065
            self.identifier()
            self.state = 2066
            self.match(CSharpParser.ASSIGNMENT)
            self.state = 2067
            self.fixed_pointer_initializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_pointer_initializerContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def AMP(self):
            return self.getToken(CSharpParser.AMP, 0)

        def local_variable_initializer_unsafe(self):
            return self.getTypedRuleContext(CSharpParser.Local_variable_initializer_unsafeContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_pointer_initializer

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_pointer_initializer" ):
                listener.enterFixed_pointer_initializer(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_pointer_initializer" ):
                listener.exitFixed_pointer_initializer(self)




    def fixed_pointer_initializer(self):

        localctx = CSharpParser.Fixed_pointer_initializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 336, self.RULE_fixed_pointer_initializer)
        try:
            self.state = 2074
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2070
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
                if la_ == 1:
                    self.state = 2069
                    self.match(CSharpParser.AMP)


                self.state = 2072
                self.expression()
                pass
            elif token in [CSharpParser.STACKALLOC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2073
                self.local_variable_initializer_unsafe()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Fixed_size_buffer_declaratorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_fixed_size_buffer_declarator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFixed_size_buffer_declarator" ):
                listener.enterFixed_size_buffer_declarator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFixed_size_buffer_declarator" ):
                listener.exitFixed_size_buffer_declarator(self)




    def fixed_size_buffer_declarator(self):

        localctx = CSharpParser.Fixed_size_buffer_declaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 338, self.RULE_fixed_size_buffer_declarator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2076
            self.identifier()
            self.state = 2077
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2078
            self.expression()
            self.state = 2079
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Local_variable_initializer_unsafeContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STACKALLOC(self):
            return self.getToken(CSharpParser.STACKALLOC, 0)

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_local_variable_initializer_unsafe

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLocal_variable_initializer_unsafe" ):
                listener.enterLocal_variable_initializer_unsafe(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLocal_variable_initializer_unsafe" ):
                listener.exitLocal_variable_initializer_unsafe(self)




    def local_variable_initializer_unsafe(self):

        localctx = CSharpParser.Local_variable_initializer_unsafeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 340, self.RULE_local_variable_initializer_unsafe)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2081
            self.match(CSharpParser.STACKALLOC)
            self.state = 2082
            self.cstype()
            self.state = 2083
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2084
            self.expression()
            self.state = 2085
            self.match(CSharpParser.CLOSE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_arrowContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.first = None # Token
            self.second = None # Token

        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_right_arrow

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRight_arrow" ):
                listener.enterRight_arrow(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRight_arrow" ):
                listener.exitRight_arrow(self)




    def right_arrow(self):

        localctx = CSharpParser.Right_arrowContext(self, self._ctx, self.state)
        self.enterRule(localctx, 342, self.RULE_right_arrow)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2087
            localctx.first = self.match(CSharpParser.ASSIGNMENT)
            self.state = 2088
            localctx.second = self.match(CSharpParser.GT)
            self.state = 2089
            if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, "$first.index + 1 == $second.index")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_shiftContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.first = None # Token
            self.second = None # Token

        def GT(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.GT)
            else:
                return self.getToken(CSharpParser.GT, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_right_shift

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRight_shift" ):
                listener.enterRight_shift(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRight_shift" ):
                listener.exitRight_shift(self)




    def right_shift(self):

        localctx = CSharpParser.Right_shiftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 344, self.RULE_right_shift)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2091
            localctx.first = self.match(CSharpParser.GT)
            self.state = 2092
            localctx.second = self.match(CSharpParser.GT)
            self.state = 2093
            if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, "$first.index + 1 == $second.index")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Right_shift_assignmentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.first = None # Token
            self.second = None # Token

        def GT(self):
            return self.getToken(CSharpParser.GT, 0)

        def OP_GE(self):
            return self.getToken(CSharpParser.OP_GE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_right_shift_assignment

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRight_shift_assignment" ):
                listener.enterRight_shift_assignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRight_shift_assignment" ):
                listener.exitRight_shift_assignment(self)




    def right_shift_assignment(self):

        localctx = CSharpParser.Right_shift_assignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 346, self.RULE_right_shift_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2095
            localctx.first = self.match(CSharpParser.GT)
            self.state = 2096
            localctx.second = self.match(CSharpParser.OP_GE)
            self.state = 2097
            if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):
                from antlr4.error.Errors import FailedPredicateException
                raise FailedPredicateException(self, "$first.index + 1 == $second.index")
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def boolean_literal(self):
            return self.getTypedRuleContext(CSharpParser.Boolean_literalContext,0)


        def string_literal(self):
            return self.getTypedRuleContext(CSharpParser.String_literalContext,0)


        def INTEGER_LITERAL(self):
            return self.getToken(CSharpParser.INTEGER_LITERAL, 0)

        def HEX_INTEGER_LITERAL(self):
            return self.getToken(CSharpParser.HEX_INTEGER_LITERAL, 0)

        def REAL_LITERAL(self):
            return self.getToken(CSharpParser.REAL_LITERAL, 0)

        def CHARACTER_LITERAL(self):
            return self.getToken(CSharpParser.CHARACTER_LITERAL, 0)

        def NULL(self):
            return self.getToken(CSharpParser.NULL, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteral" ):
                listener.enterLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteral" ):
                listener.exitLiteral(self)




    def literal(self):

        localctx = CSharpParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 348, self.RULE_literal)
        try:
            self.state = 2106
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.FALSE, CSharpParser.TRUE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2099
                self.boolean_literal()
                pass
            elif token in [CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2100
                self.string_literal()
                pass
            elif token in [CSharpParser.INTEGER_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2101
                self.match(CSharpParser.INTEGER_LITERAL)
                pass
            elif token in [CSharpParser.HEX_INTEGER_LITERAL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2102
                self.match(CSharpParser.HEX_INTEGER_LITERAL)
                pass
            elif token in [CSharpParser.REAL_LITERAL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 2103
                self.match(CSharpParser.REAL_LITERAL)
                pass
            elif token in [CSharpParser.CHARACTER_LITERAL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 2104
                self.match(CSharpParser.CHARACTER_LITERAL)
                pass
            elif token in [CSharpParser.NULL]:
                self.enterOuterAlt(localctx, 7)
                self.state = 2105
                self.match(CSharpParser.NULL)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Boolean_literalContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE(self):
            return self.getToken(CSharpParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(CSharpParser.FALSE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_boolean_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBoolean_literal" ):
                listener.enterBoolean_literal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBoolean_literal" ):
                listener.exitBoolean_literal(self)




    def boolean_literal(self):

        localctx = CSharpParser.Boolean_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 350, self.RULE_boolean_literal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2108
            _la = self._input.LA(1)
            if not(_la==CSharpParser.FALSE or _la==CSharpParser.TRUE):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class String_literalContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interpolated_regular_string(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_regular_stringContext,0)


        def interpolated_verbatium_string(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_verbatium_stringContext,0)


        def REGULAR_STRING(self):
            return self.getToken(CSharpParser.REGULAR_STRING, 0)

        def VERBATIUM_STRING(self):
            return self.getToken(CSharpParser.VERBATIUM_STRING, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_string_literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterString_literal" ):
                listener.enterString_literal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitString_literal" ):
                listener.exitString_literal(self)




    def string_literal(self):

        localctx = CSharpParser.String_literalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 352, self.RULE_string_literal)
        try:
            self.state = 2114
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.INTERPOLATED_REGULAR_STRING_START]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2110
                self.interpolated_regular_string()
                pass
            elif token in [CSharpParser.INTERPOLATED_VERBATIUM_STRING_START]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2111
                self.interpolated_verbatium_string()
                pass
            elif token in [CSharpParser.REGULAR_STRING]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2112
                self.match(CSharpParser.REGULAR_STRING)
                pass
            elif token in [CSharpParser.VERBATIUM_STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2113
                self.match(CSharpParser.VERBATIUM_STRING)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_regular_stringContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERPOLATED_REGULAR_STRING_START(self):
            return self.getToken(CSharpParser.INTERPOLATED_REGULAR_STRING_START, 0)

        def DOUBLE_QUOTE_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0)

        def interpolated_regular_string_part(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Interpolated_regular_string_partContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Interpolated_regular_string_partContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_regular_string

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_regular_string" ):
                listener.enterInterpolated_regular_string(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_regular_string" ):
                listener.exitInterpolated_regular_string(self)




    def interpolated_regular_string(self):

        localctx = CSharpParser.Interpolated_regular_stringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 354, self.RULE_interpolated_regular_string)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2116
            self.match(CSharpParser.INTERPOLATED_REGULAR_STRING_START)
            self.state = 2120
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)) | (1 << (CSharpParser.DOUBLE_CURLY_INSIDE - 132)) | (1 << (CSharpParser.REGULAR_CHAR_INSIDE - 132)) | (1 << (CSharpParser.REGULAR_STRING_INSIDE - 132)))) != 0):
                self.state = 2117
                self.interpolated_regular_string_part()
                self.state = 2122
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2123
            self.match(CSharpParser.DOUBLE_QUOTE_INSIDE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_verbatium_stringContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERPOLATED_VERBATIUM_STRING_START(self):
            return self.getToken(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, 0)

        def DOUBLE_QUOTE_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0)

        def interpolated_verbatium_string_part(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Interpolated_verbatium_string_partContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Interpolated_verbatium_string_partContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_verbatium_string

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_verbatium_string" ):
                listener.enterInterpolated_verbatium_string(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_verbatium_string" ):
                listener.exitInterpolated_verbatium_string(self)




    def interpolated_verbatium_string(self):

        localctx = CSharpParser.Interpolated_verbatium_stringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 356, self.RULE_interpolated_verbatium_string)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2125
            self.match(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START)
            self.state = 2129
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)) | (1 << (CSharpParser.DOUBLE_CURLY_INSIDE - 132)) | (1 << (CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE - 132)) | (1 << (CSharpParser.VERBATIUM_INSIDE_STRING - 132)))) != 0):
                self.state = 2126
                self.interpolated_verbatium_string_part()
                self.state = 2131
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2132
            self.match(CSharpParser.DOUBLE_QUOTE_INSIDE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_regular_string_partContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interpolated_string_expression(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_string_expressionContext,0)


        def DOUBLE_CURLY_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0)

        def REGULAR_CHAR_INSIDE(self):
            return self.getToken(CSharpParser.REGULAR_CHAR_INSIDE, 0)

        def REGULAR_STRING_INSIDE(self):
            return self.getToken(CSharpParser.REGULAR_STRING_INSIDE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_regular_string_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_regular_string_part" ):
                listener.enterInterpolated_regular_string_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_regular_string_part" ):
                listener.exitInterpolated_regular_string_part(self)




    def interpolated_regular_string_part(self):

        localctx = CSharpParser.Interpolated_regular_string_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 358, self.RULE_interpolated_regular_string_part)
        try:
            self.state = 2138
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2134
                self.interpolated_string_expression()
                pass
            elif token in [CSharpParser.DOUBLE_CURLY_INSIDE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2135
                self.match(CSharpParser.DOUBLE_CURLY_INSIDE)
                pass
            elif token in [CSharpParser.REGULAR_CHAR_INSIDE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2136
                self.match(CSharpParser.REGULAR_CHAR_INSIDE)
                pass
            elif token in [CSharpParser.REGULAR_STRING_INSIDE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2137
                self.match(CSharpParser.REGULAR_STRING_INSIDE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_verbatium_string_partContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interpolated_string_expression(self):
            return self.getTypedRuleContext(CSharpParser.Interpolated_string_expressionContext,0)


        def DOUBLE_CURLY_INSIDE(self):
            return self.getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0)

        def VERBATIUM_DOUBLE_QUOTE_INSIDE(self):
            return self.getToken(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE, 0)

        def VERBATIUM_INSIDE_STRING(self):
            return self.getToken(CSharpParser.VERBATIUM_INSIDE_STRING, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_verbatium_string_part

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_verbatium_string_part" ):
                listener.enterInterpolated_verbatium_string_part(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_verbatium_string_part" ):
                listener.exitInterpolated_verbatium_string_part(self)




    def interpolated_verbatium_string_part(self):

        localctx = CSharpParser.Interpolated_verbatium_string_partContext(self, self._ctx, self.state)
        self.enterRule(localctx, 360, self.RULE_interpolated_verbatium_string_part)
        try:
            self.state = 2144
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC]:
                self.enterOuterAlt(localctx, 1)
                self.state = 2140
                self.interpolated_string_expression()
                pass
            elif token in [CSharpParser.DOUBLE_CURLY_INSIDE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 2141
                self.match(CSharpParser.DOUBLE_CURLY_INSIDE)
                pass
            elif token in [CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 2142
                self.match(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE)
                pass
            elif token in [CSharpParser.VERBATIUM_INSIDE_STRING]:
                self.enterOuterAlt(localctx, 4)
                self.state = 2143
                self.match(CSharpParser.VERBATIUM_INSIDE_STRING)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interpolated_string_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.COMMA)
            else:
                return self.getToken(CSharpParser.COMMA, i)

        def COLON(self):
            return self.getToken(CSharpParser.COLON, 0)

        def FORMAT_STRING(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.FORMAT_STRING)
            else:
                return self.getToken(CSharpParser.FORMAT_STRING, i)

        def getRuleIndex(self):
            return CSharpParser.RULE_interpolated_string_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterpolated_string_expression" ):
                listener.enterInterpolated_string_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterpolated_string_expression" ):
                listener.exitInterpolated_string_expression(self)




    def interpolated_string_expression(self):

        localctx = CSharpParser.Interpolated_string_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 362, self.RULE_interpolated_string_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2146
            self.expression()
            self.state = 2151
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==CSharpParser.COMMA:
                self.state = 2147
                self.match(CSharpParser.COMMA)
                self.state = 2148
                self.expression()
                self.state = 2153
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 2160
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2154
                self.match(CSharpParser.COLON)
                self.state = 2156 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 2155
                    self.match(CSharpParser.FORMAT_STRING)
                    self.state = 2158 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==CSharpParser.FORMAT_STRING):
                        break



        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class KeywordContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ABSTRACT(self):
            return self.getToken(CSharpParser.ABSTRACT, 0)

        def AS(self):
            return self.getToken(CSharpParser.AS, 0)

        def BASE(self):
            return self.getToken(CSharpParser.BASE, 0)

        def BOOL(self):
            return self.getToken(CSharpParser.BOOL, 0)

        def BREAK(self):
            return self.getToken(CSharpParser.BREAK, 0)

        def BYTE(self):
            return self.getToken(CSharpParser.BYTE, 0)

        def CASE(self):
            return self.getToken(CSharpParser.CASE, 0)

        def CATCH(self):
            return self.getToken(CSharpParser.CATCH, 0)

        def CHAR(self):
            return self.getToken(CSharpParser.CHAR, 0)

        def CHECKED(self):
            return self.getToken(CSharpParser.CHECKED, 0)

        def CLASS(self):
            return self.getToken(CSharpParser.CLASS, 0)

        def CONST(self):
            return self.getToken(CSharpParser.CONST, 0)

        def CONTINUE(self):
            return self.getToken(CSharpParser.CONTINUE, 0)

        def DECIMAL(self):
            return self.getToken(CSharpParser.DECIMAL, 0)

        def DEFAULT(self):
            return self.getToken(CSharpParser.DEFAULT, 0)

        def DELEGATE(self):
            return self.getToken(CSharpParser.DELEGATE, 0)

        def DO(self):
            return self.getToken(CSharpParser.DO, 0)

        def DOUBLE(self):
            return self.getToken(CSharpParser.DOUBLE, 0)

        def ELSE(self):
            return self.getToken(CSharpParser.ELSE, 0)

        def ENUM(self):
            return self.getToken(CSharpParser.ENUM, 0)

        def EVENT(self):
            return self.getToken(CSharpParser.EVENT, 0)

        def EXPLICIT(self):
            return self.getToken(CSharpParser.EXPLICIT, 0)

        def EXTERN(self):
            return self.getToken(CSharpParser.EXTERN, 0)

        def FALSE(self):
            return self.getToken(CSharpParser.FALSE, 0)

        def FINALLY(self):
            return self.getToken(CSharpParser.FINALLY, 0)

        def FIXED(self):
            return self.getToken(CSharpParser.FIXED, 0)

        def FLOAT(self):
            return self.getToken(CSharpParser.FLOAT, 0)

        def FOR(self):
            return self.getToken(CSharpParser.FOR, 0)

        def FOREACH(self):
            return self.getToken(CSharpParser.FOREACH, 0)

        def GOTO(self):
            return self.getToken(CSharpParser.GOTO, 0)

        def IF(self):
            return self.getToken(CSharpParser.IF, 0)

        def IMPLICIT(self):
            return self.getToken(CSharpParser.IMPLICIT, 0)

        def IN(self):
            return self.getToken(CSharpParser.IN, 0)

        def INT(self):
            return self.getToken(CSharpParser.INT, 0)

        def INTERFACE(self):
            return self.getToken(CSharpParser.INTERFACE, 0)

        def INTERNAL(self):
            return self.getToken(CSharpParser.INTERNAL, 0)

        def IS(self):
            return self.getToken(CSharpParser.IS, 0)

        def LOCK(self):
            return self.getToken(CSharpParser.LOCK, 0)

        def LONG(self):
            return self.getToken(CSharpParser.LONG, 0)

        def NAMESPACE(self):
            return self.getToken(CSharpParser.NAMESPACE, 0)

        def NEW(self):
            return self.getToken(CSharpParser.NEW, 0)

        def NULL(self):
            return self.getToken(CSharpParser.NULL, 0)

        def OBJECT(self):
            return self.getToken(CSharpParser.OBJECT, 0)

        def OPERATOR(self):
            return self.getToken(CSharpParser.OPERATOR, 0)

        def OUT(self):
            return self.getToken(CSharpParser.OUT, 0)

        def OVERRIDE(self):
            return self.getToken(CSharpParser.OVERRIDE, 0)

        def PARAMS(self):
            return self.getToken(CSharpParser.PARAMS, 0)

        def PRIVATE(self):
            return self.getToken(CSharpParser.PRIVATE, 0)

        def PROTECTED(self):
            return self.getToken(CSharpParser.PROTECTED, 0)

        def PUBLIC(self):
            return self.getToken(CSharpParser.PUBLIC, 0)

        def READONLY(self):
            return self.getToken(CSharpParser.READONLY, 0)

        def REF(self):
            return self.getToken(CSharpParser.REF, 0)

        def RETURN(self):
            return self.getToken(CSharpParser.RETURN, 0)

        def SBYTE(self):
            return self.getToken(CSharpParser.SBYTE, 0)

        def SEALED(self):
            return self.getToken(CSharpParser.SEALED, 0)

        def SHORT(self):
            return self.getToken(CSharpParser.SHORT, 0)

        def SIZEOF(self):
            return self.getToken(CSharpParser.SIZEOF, 0)

        def STACKALLOC(self):
            return self.getToken(CSharpParser.STACKALLOC, 0)

        def STATIC(self):
            return self.getToken(CSharpParser.STATIC, 0)

        def STRING(self):
            return self.getToken(CSharpParser.STRING, 0)

        def STRUCT(self):
            return self.getToken(CSharpParser.STRUCT, 0)

        def SWITCH(self):
            return self.getToken(CSharpParser.SWITCH, 0)

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def THROW(self):
            return self.getToken(CSharpParser.THROW, 0)

        def TRUE(self):
            return self.getToken(CSharpParser.TRUE, 0)

        def TRY(self):
            return self.getToken(CSharpParser.TRY, 0)

        def TYPEOF(self):
            return self.getToken(CSharpParser.TYPEOF, 0)

        def UINT(self):
            return self.getToken(CSharpParser.UINT, 0)

        def ULONG(self):
            return self.getToken(CSharpParser.ULONG, 0)

        def UNCHECKED(self):
            return self.getToken(CSharpParser.UNCHECKED, 0)

        def UNSAFE(self):
            return self.getToken(CSharpParser.UNSAFE, 0)

        def USHORT(self):
            return self.getToken(CSharpParser.USHORT, 0)

        def USING(self):
            return self.getToken(CSharpParser.USING, 0)

        def VIRTUAL(self):
            return self.getToken(CSharpParser.VIRTUAL, 0)

        def VOID(self):
            return self.getToken(CSharpParser.VOID, 0)

        def VOLATILE(self):
            return self.getToken(CSharpParser.VOLATILE, 0)

        def WHILE(self):
            return self.getToken(CSharpParser.WHILE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_keyword

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterKeyword" ):
                listener.enterKeyword(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitKeyword" ):
                listener.exitKeyword(self)




    def keyword(self):

        localctx = CSharpParser.KeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 364, self.RULE_keyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2162
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.AS) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BREAK) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CASE) | (1 << CSharpParser.CATCH) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.CLASS) | (1 << CSharpParser.CONST) | (1 << CSharpParser.CONTINUE) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DO) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.ELSE) | (1 << CSharpParser.ENUM) | (1 << CSharpParser.EVENT) | (1 << CSharpParser.EXPLICIT) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FINALLY) | (1 << CSharpParser.FIXED) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FOR) | (1 << CSharpParser.FOREACH) | (1 << CSharpParser.GOTO) | (1 << CSharpParser.IF) | (1 << CSharpParser.IMPLICIT) | (1 << CSharpParser.IN) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTERFACE) | (1 << CSharpParser.INTERNAL) | (1 << CSharpParser.IS) | (1 << CSharpParser.LOCK) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & ((1 << (CSharpParser.NAMESPACE - 64)) | (1 << (CSharpParser.NEW - 64)) | (1 << (CSharpParser.NULL - 64)) | (1 << (CSharpParser.OBJECT - 64)) | (1 << (CSharpParser.OPERATOR - 64)) | (1 << (CSharpParser.OUT - 64)) | (1 << (CSharpParser.OVERRIDE - 64)) | (1 << (CSharpParser.PARAMS - 64)) | (1 << (CSharpParser.PRIVATE - 64)) | (1 << (CSharpParser.PROTECTED - 64)) | (1 << (CSharpParser.PUBLIC - 64)) | (1 << (CSharpParser.READONLY - 64)) | (1 << (CSharpParser.REF - 64)) | (1 << (CSharpParser.RETURN - 64)) | (1 << (CSharpParser.SBYTE - 64)) | (1 << (CSharpParser.SEALED - 64)) | (1 << (CSharpParser.SHORT - 64)) | (1 << (CSharpParser.SIZEOF - 64)) | (1 << (CSharpParser.STACKALLOC - 64)) | (1 << (CSharpParser.STATIC - 64)) | (1 << (CSharpParser.STRING - 64)) | (1 << (CSharpParser.STRUCT - 64)) | (1 << (CSharpParser.SWITCH - 64)) | (1 << (CSharpParser.THIS - 64)) | (1 << (CSharpParser.THROW - 64)) | (1 << (CSharpParser.TRUE - 64)) | (1 << (CSharpParser.TRY - 64)) | (1 << (CSharpParser.TYPEOF - 64)) | (1 << (CSharpParser.UINT - 64)) | (1 << (CSharpParser.ULONG - 64)) | (1 << (CSharpParser.UNCHECKED - 64)) | (1 << (CSharpParser.UNSAFE - 64)) | (1 << (CSharpParser.USHORT - 64)) | (1 << (CSharpParser.USING - 64)) | (1 << (CSharpParser.VIRTUAL - 64)) | (1 << (CSharpParser.VOID - 64)) | (1 << (CSharpParser.VOLATILE - 64)) | (1 << (CSharpParser.WHILE - 64)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_definitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CLASS(self):
            return self.getToken(CSharpParser.CLASS, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def class_body(self):
            return self.getTypedRuleContext(CSharpParser.Class_bodyContext,0)


        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def class_base(self):
            return self.getTypedRuleContext(CSharpParser.Class_baseContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_class_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterClass_definition" ):
                listener.enterClass_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitClass_definition" ):
                listener.exitClass_definition(self)




    def class_definition(self):

        localctx = CSharpParser.Class_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 366, self.RULE_class_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2164
            self.match(CSharpParser.CLASS)
            self.state = 2165
            self.identifier()
            self.state = 2167
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2166
                self.type_parameter_list()


            self.state = 2170
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2169
                self.class_base()


            self.state = 2173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2172
                self.type_parameter_constraints_clauses()


            self.state = 2175
            self.class_body()
            self.state = 2177
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2176
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Struct_definitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRUCT(self):
            return self.getToken(CSharpParser.STRUCT, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def struct_body(self):
            return self.getTypedRuleContext(CSharpParser.Struct_bodyContext,0)


        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def struct_interfaces(self):
            return self.getTypedRuleContext(CSharpParser.Struct_interfacesContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_struct_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStruct_definition" ):
                listener.enterStruct_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStruct_definition" ):
                listener.exitStruct_definition(self)




    def struct_definition(self):

        localctx = CSharpParser.Struct_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 368, self.RULE_struct_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2179
            self.match(CSharpParser.STRUCT)
            self.state = 2180
            self.identifier()
            self.state = 2182
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2181
                self.type_parameter_list()


            self.state = 2185
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2184
                self.struct_interfaces()


            self.state = 2188
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2187
                self.type_parameter_constraints_clauses()


            self.state = 2190
            self.struct_body()
            self.state = 2192
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2191
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Interface_definitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERFACE(self):
            return self.getToken(CSharpParser.INTERFACE, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def interface_body(self):
            return self.getTypedRuleContext(CSharpParser.Interface_bodyContext,0)


        def variant_type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Variant_type_parameter_listContext,0)


        def interface_base(self):
            return self.getTypedRuleContext(CSharpParser.Interface_baseContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_interface_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInterface_definition" ):
                listener.enterInterface_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInterface_definition" ):
                listener.exitInterface_definition(self)




    def interface_definition(self):

        localctx = CSharpParser.Interface_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 370, self.RULE_interface_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2194
            self.match(CSharpParser.INTERFACE)
            self.state = 2195
            self.identifier()
            self.state = 2197
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2196
                self.variant_type_parameter_list()


            self.state = 2200
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2199
                self.interface_base()


            self.state = 2203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2202
                self.type_parameter_constraints_clauses()


            self.state = 2205
            self.interface_body()
            self.state = 2207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2206
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Enum_definitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENUM(self):
            return self.getToken(CSharpParser.ENUM, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def enum_body(self):
            return self.getTypedRuleContext(CSharpParser.Enum_bodyContext,0)


        def enum_base(self):
            return self.getTypedRuleContext(CSharpParser.Enum_baseContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_enum_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEnum_definition" ):
                listener.enterEnum_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEnum_definition" ):
                listener.exitEnum_definition(self)




    def enum_definition(self):

        localctx = CSharpParser.Enum_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 372, self.RULE_enum_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2209
            self.match(CSharpParser.ENUM)
            self.state = 2210
            self.identifier()
            self.state = 2212
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2211
                self.enum_base()


            self.state = 2214
            self.enum_body()
            self.state = 2216
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.SEMICOLON:
                self.state = 2215
                self.match(CSharpParser.SEMICOLON)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Delegate_definitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DELEGATE(self):
            return self.getToken(CSharpParser.DELEGATE, 0)

        def return_type(self):
            return self.getTypedRuleContext(CSharpParser.Return_typeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def variant_type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Variant_type_parameter_listContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_delegate_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDelegate_definition" ):
                listener.enterDelegate_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDelegate_definition" ):
                listener.exitDelegate_definition(self)




    def delegate_definition(self):

        localctx = CSharpParser.Delegate_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 374, self.RULE_delegate_definition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2218
            self.match(CSharpParser.DELEGATE)
            self.state = 2219
            self.return_type()
            self.state = 2220
            self.identifier()
            self.state = 2222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2221
                self.variant_type_parameter_list()


            self.state = 2224
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2226
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CSharpParser.OBJECT - 67)) | (1 << (CSharpParser.ON - 67)) | (1 << (CSharpParser.ORDERBY - 67)) | (1 << (CSharpParser.OUT - 67)) | (1 << (CSharpParser.PARAMS - 67)) | (1 << (CSharpParser.PARTIAL - 67)) | (1 << (CSharpParser.REF - 67)) | (1 << (CSharpParser.REMOVE - 67)) | (1 << (CSharpParser.SBYTE - 67)) | (1 << (CSharpParser.SELECT - 67)) | (1 << (CSharpParser.SET - 67)) | (1 << (CSharpParser.SHORT - 67)) | (1 << (CSharpParser.STRING - 67)) | (1 << (CSharpParser.THIS - 67)) | (1 << (CSharpParser.UINT - 67)) | (1 << (CSharpParser.ULONG - 67)) | (1 << (CSharpParser.USHORT - 67)) | (1 << (CSharpParser.VAR - 67)) | (1 << (CSharpParser.VOID - 67)) | (1 << (CSharpParser.WHEN - 67)) | (1 << (CSharpParser.WHERE - 67)) | (1 << (CSharpParser.YIELD - 67)) | (1 << (CSharpParser.IDENTIFIER - 67)) | (1 << (CSharpParser.OPEN_BRACKET - 67)))) != 0):
                self.state = 2225
                self.formal_parameter_list()


            self.state = 2228
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2229
                self.type_parameter_constraints_clauses()


            self.state = 2232
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Event_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EVENT(self):
            return self.getToken(CSharpParser.EVENT, 0)

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def variable_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Variable_declaratorsContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def member_name(self):
            return self.getTypedRuleContext(CSharpParser.Member_nameContext,0)


        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def event_accessor_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Event_accessor_declarationsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_event_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEvent_declaration" ):
                listener.enterEvent_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEvent_declaration" ):
                listener.exitEvent_declaration(self)




    def event_declaration(self):

        localctx = CSharpParser.Event_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 376, self.RULE_event_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2234
            self.match(CSharpParser.EVENT)
            self.state = 2235
            self.cstype()
            self.state = 2244
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,280,self._ctx)
            if la_ == 1:
                self.state = 2236
                self.variable_declarators()
                self.state = 2237
                self.match(CSharpParser.SEMICOLON)
                pass

            elif la_ == 2:
                self.state = 2239
                self.member_name()
                self.state = 2240
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2241
                self.event_accessor_declarations()
                self.state = 2242
                self.match(CSharpParser.CLOSE_BRACE)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Field_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variable_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Variable_declaratorsContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_field_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterField_declaration" ):
                listener.enterField_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitField_declaration" ):
                listener.exitField_declaration(self)




    def field_declaration(self):

        localctx = CSharpParser.Field_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 378, self.RULE_field_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2246
            self.variable_declarators()
            self.state = 2247
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Property_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def member_name(self):
            return self.getTypedRuleContext(CSharpParser.Member_nameContext,0)


        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def accessor_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_declarationsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def variable_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_property_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterProperty_declaration" ):
                listener.enterProperty_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitProperty_declaration" ):
                listener.exitProperty_declaration(self)




    def property_declaration(self):

        localctx = CSharpParser.Property_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 380, self.RULE_property_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2249
            self.member_name()
            self.state = 2263
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.state = 2250
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2251
                self.accessor_declarations()
                self.state = 2252
                self.match(CSharpParser.CLOSE_BRACE)
                self.state = 2257
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==CSharpParser.ASSIGNMENT:
                    self.state = 2253
                    self.match(CSharpParser.ASSIGNMENT)
                    self.state = 2254
                    self.variable_initializer()
                    self.state = 2255
                    self.match(CSharpParser.SEMICOLON)


                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2259
                self.right_arrow()
                self.state = 2260
                self.expression()
                self.state = 2261
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constant_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CONST(self):
            return self.getToken(CSharpParser.CONST, 0)

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def constant_declarators(self):
            return self.getTypedRuleContext(CSharpParser.Constant_declaratorsContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_constant_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstant_declaration" ):
                listener.enterConstant_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstant_declaration" ):
                listener.exitConstant_declaration(self)




    def constant_declaration(self):

        localctx = CSharpParser.Constant_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 382, self.RULE_constant_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2265
            self.match(CSharpParser.CONST)
            self.state = 2266
            self.cstype()
            self.state = 2267
            self.constant_declarators()
            self.state = 2268
            self.match(CSharpParser.SEMICOLON)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Indexer_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def THIS(self):
            return self.getToken(CSharpParser.THIS, 0)

        def OPEN_BRACKET(self):
            return self.getToken(CSharpParser.OPEN_BRACKET, 0)

        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def CLOSE_BRACKET(self):
            return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

        def OPEN_BRACE(self):
            return self.getToken(CSharpParser.OPEN_BRACE, 0)

        def accessor_declarations(self):
            return self.getTypedRuleContext(CSharpParser.Accessor_declarationsContext,0)


        def CLOSE_BRACE(self):
            return self.getToken(CSharpParser.CLOSE_BRACE, 0)

        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_indexer_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIndexer_declaration" ):
                listener.enterIndexer_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIndexer_declaration" ):
                listener.exitIndexer_declaration(self)




    def indexer_declaration(self):

        localctx = CSharpParser.Indexer_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 384, self.RULE_indexer_declaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2270
            self.match(CSharpParser.THIS)
            self.state = 2271
            self.match(CSharpParser.OPEN_BRACKET)
            self.state = 2272
            self.formal_parameter_list()
            self.state = 2273
            self.match(CSharpParser.CLOSE_BRACKET)
            self.state = 2282
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE]:
                self.state = 2274
                self.match(CSharpParser.OPEN_BRACE)
                self.state = 2275
                self.accessor_declarations()
                self.state = 2276
                self.match(CSharpParser.CLOSE_BRACE)
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2278
                self.right_arrow()
                self.state = 2279
                self.expression()
                self.state = 2280
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Destructor_definitionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TILDE(self):
            return self.getToken(CSharpParser.TILDE, 0)

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_destructor_definition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDestructor_definition" ):
                listener.enterDestructor_definition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDestructor_definition" ):
                listener.exitDestructor_definition(self)




    def destructor_definition(self):

        localctx = CSharpParser.Destructor_definitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 386, self.RULE_destructor_definition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2284
            self.match(CSharpParser.TILDE)
            self.state = 2285
            self.identifier()
            self.state = 2286
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2287
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2288
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Constructor_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def constructor_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Constructor_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_constructor_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstructor_declaration" ):
                listener.enterConstructor_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstructor_declaration" ):
                listener.exitConstructor_declaration(self)




    def constructor_declaration(self):

        localctx = CSharpParser.Constructor_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 388, self.RULE_constructor_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2290
            self.identifier()
            self.state = 2291
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2293
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CSharpParser.OBJECT - 67)) | (1 << (CSharpParser.ON - 67)) | (1 << (CSharpParser.ORDERBY - 67)) | (1 << (CSharpParser.OUT - 67)) | (1 << (CSharpParser.PARAMS - 67)) | (1 << (CSharpParser.PARTIAL - 67)) | (1 << (CSharpParser.REF - 67)) | (1 << (CSharpParser.REMOVE - 67)) | (1 << (CSharpParser.SBYTE - 67)) | (1 << (CSharpParser.SELECT - 67)) | (1 << (CSharpParser.SET - 67)) | (1 << (CSharpParser.SHORT - 67)) | (1 << (CSharpParser.STRING - 67)) | (1 << (CSharpParser.THIS - 67)) | (1 << (CSharpParser.UINT - 67)) | (1 << (CSharpParser.ULONG - 67)) | (1 << (CSharpParser.USHORT - 67)) | (1 << (CSharpParser.VAR - 67)) | (1 << (CSharpParser.VOID - 67)) | (1 << (CSharpParser.WHEN - 67)) | (1 << (CSharpParser.WHERE - 67)) | (1 << (CSharpParser.YIELD - 67)) | (1 << (CSharpParser.IDENTIFIER - 67)) | (1 << (CSharpParser.OPEN_BRACKET - 67)))) != 0):
                self.state = 2292
                self.formal_parameter_list()


            self.state = 2295
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2297
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COLON:
                self.state = 2296
                self.constructor_initializer()


            self.state = 2299
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Method_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def method_member_name(self):
            return self.getTypedRuleContext(CSharpParser.Method_member_nameContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def method_body(self):
            return self.getTypedRuleContext(CSharpParser.Method_bodyContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def type_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)


        def formal_parameter_list(self):
            return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)


        def type_parameter_constraints_clauses(self):
            return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_method_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_declaration" ):
                listener.enterMethod_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_declaration" ):
                listener.exitMethod_declaration(self)




    def method_declaration(self):

        localctx = CSharpParser.Method_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 390, self.RULE_method_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2301
            self.method_member_name()
            self.state = 2303
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.LT:
                self.state = 2302
                self.type_parameter_list()


            self.state = 2305
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2307
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (CSharpParser.OBJECT - 67)) | (1 << (CSharpParser.ON - 67)) | (1 << (CSharpParser.ORDERBY - 67)) | (1 << (CSharpParser.OUT - 67)) | (1 << (CSharpParser.PARAMS - 67)) | (1 << (CSharpParser.PARTIAL - 67)) | (1 << (CSharpParser.REF - 67)) | (1 << (CSharpParser.REMOVE - 67)) | (1 << (CSharpParser.SBYTE - 67)) | (1 << (CSharpParser.SELECT - 67)) | (1 << (CSharpParser.SET - 67)) | (1 << (CSharpParser.SHORT - 67)) | (1 << (CSharpParser.STRING - 67)) | (1 << (CSharpParser.THIS - 67)) | (1 << (CSharpParser.UINT - 67)) | (1 << (CSharpParser.ULONG - 67)) | (1 << (CSharpParser.USHORT - 67)) | (1 << (CSharpParser.VAR - 67)) | (1 << (CSharpParser.VOID - 67)) | (1 << (CSharpParser.WHEN - 67)) | (1 << (CSharpParser.WHERE - 67)) | (1 << (CSharpParser.YIELD - 67)) | (1 << (CSharpParser.IDENTIFIER - 67)) | (1 << (CSharpParser.OPEN_BRACKET - 67)))) != 0):
                self.state = 2306
                self.formal_parameter_list()


            self.state = 2309
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2311
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.WHERE:
                self.state = 2310
                self.type_parameter_constraints_clauses()


            self.state = 2318
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:
                self.state = 2313
                self.method_body()
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2314
                self.right_arrow()
                self.state = 2315
                self.expression()
                self.state = 2316
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Method_member_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def identifier(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.IdentifierContext)
            else:
                return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)


        def DOUBLE_COLON(self):
            return self.getToken(CSharpParser.DOUBLE_COLON, 0)

        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(CSharpParser.DOT)
            else:
                return self.getToken(CSharpParser.DOT, i)

        def type_argument_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Type_argument_listContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,i)


        def getRuleIndex(self):
            return CSharpParser.RULE_method_member_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_member_name" ):
                listener.enterMethod_member_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_member_name" ):
                listener.exitMethod_member_name(self)




    def method_member_name(self):

        localctx = CSharpParser.Method_member_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 392, self.RULE_method_member_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2325
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,290,self._ctx)
            if la_ == 1:
                self.state = 2320
                self.identifier()
                pass

            elif la_ == 2:
                self.state = 2321
                self.identifier()
                self.state = 2322
                self.match(CSharpParser.DOUBLE_COLON)
                self.state = 2323
                self.identifier()
                pass


            self.state = 2334
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,292,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 2328
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==CSharpParser.LT:
                        self.state = 2327
                        self.type_argument_list()


                    self.state = 2330
                    self.match(CSharpParser.DOT)
                    self.state = 2331
                    self.identifier() 
                self.state = 2336
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,292,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Operator_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPERATOR(self):
            return self.getToken(CSharpParser.OPERATOR, 0)

        def overloadable_operator(self):
            return self.getTypedRuleContext(CSharpParser.Overloadable_operatorContext,0)


        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def arg_declaration(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(CSharpParser.Arg_declarationContext)
            else:
                return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,i)


        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def body(self):
            return self.getTypedRuleContext(CSharpParser.BodyContext,0)


        def right_arrow(self):
            return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)


        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def SEMICOLON(self):
            return self.getToken(CSharpParser.SEMICOLON, 0)

        def COMMA(self):
            return self.getToken(CSharpParser.COMMA, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_operator_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOperator_declaration" ):
                listener.enterOperator_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOperator_declaration" ):
                listener.exitOperator_declaration(self)




    def operator_declaration(self):

        localctx = CSharpParser.Operator_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 394, self.RULE_operator_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2337
            self.match(CSharpParser.OPERATOR)
            self.state = 2338
            self.overloadable_operator()
            self.state = 2339
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2340
            self.arg_declaration()
            self.state = 2343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.COMMA:
                self.state = 2341
                self.match(CSharpParser.COMMA)
                self.state = 2342
                self.arg_declaration()


            self.state = 2345
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2351
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:
                self.state = 2346
                self.body()
                pass
            elif token in [CSharpParser.ASSIGNMENT]:
                self.state = 2347
                self.right_arrow()
                self.state = 2348
                self.expression()
                self.state = 2349
                self.match(CSharpParser.SEMICOLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Arg_declarationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def cstype(self):
            return self.getTypedRuleContext(CSharpParser.CstypeContext,0)


        def identifier(self):
            return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)


        def ASSIGNMENT(self):
            return self.getToken(CSharpParser.ASSIGNMENT, 0)

        def expression(self):
            return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_arg_declaration

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterArg_declaration" ):
                listener.enterArg_declaration(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitArg_declaration" ):
                listener.exitArg_declaration(self)




    def arg_declaration(self):

        localctx = CSharpParser.Arg_declarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 396, self.RULE_arg_declaration)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2353
            self.cstype()
            self.state = 2354
            self.identifier()
            self.state = 2357
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.ASSIGNMENT:
                self.state = 2355
                self.match(CSharpParser.ASSIGNMENT)
                self.state = 2356
                self.expression()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Method_invocationContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_method_invocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMethod_invocation" ):
                listener.enterMethod_invocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMethod_invocation" ):
                listener.exitMethod_invocation(self)




    def method_invocation(self):

        localctx = CSharpParser.Method_invocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 398, self.RULE_method_invocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2359
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2361
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.OUT - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)))) != 0):
                self.state = 2360
                self.argument_list()


            self.state = 2363
            self.match(CSharpParser.CLOSE_PARENS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Object_creation_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PARENS(self):
            return self.getToken(CSharpParser.OPEN_PARENS, 0)

        def CLOSE_PARENS(self):
            return self.getToken(CSharpParser.CLOSE_PARENS, 0)

        def argument_list(self):
            return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)


        def object_or_collection_initializer(self):
            return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)


        def getRuleIndex(self):
            return CSharpParser.RULE_object_creation_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterObject_creation_expression" ):
                listener.enterObject_creation_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitObject_creation_expression" ):
                listener.exitObject_creation_expression(self)




    def object_creation_expression(self):

        localctx = CSharpParser.Object_creation_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 400, self.RULE_object_creation_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2365
            self.match(CSharpParser.OPEN_PARENS)
            self.state = 2367
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BASE) | (1 << CSharpParser.BOOL) | (1 << CSharpParser.BY) | (1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.CHECKED) | (1 << CSharpParser.DECIMAL) | (1 << CSharpParser.DEFAULT) | (1 << CSharpParser.DELEGATE) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DOUBLE) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FALSE) | (1 << CSharpParser.FLOAT) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INT) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.LONG) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 65)) & ~0x3f) == 0 and ((1 << (_la - 65)) & ((1 << (CSharpParser.NEW - 65)) | (1 << (CSharpParser.NULL - 65)) | (1 << (CSharpParser.OBJECT - 65)) | (1 << (CSharpParser.ON - 65)) | (1 << (CSharpParser.ORDERBY - 65)) | (1 << (CSharpParser.OUT - 65)) | (1 << (CSharpParser.PARTIAL - 65)) | (1 << (CSharpParser.REF - 65)) | (1 << (CSharpParser.REMOVE - 65)) | (1 << (CSharpParser.SBYTE - 65)) | (1 << (CSharpParser.SELECT - 65)) | (1 << (CSharpParser.SET - 65)) | (1 << (CSharpParser.SHORT - 65)) | (1 << (CSharpParser.SIZEOF - 65)) | (1 << (CSharpParser.STRING - 65)) | (1 << (CSharpParser.THIS - 65)) | (1 << (CSharpParser.TRUE - 65)) | (1 << (CSharpParser.TYPEOF - 65)) | (1 << (CSharpParser.UINT - 65)) | (1 << (CSharpParser.ULONG - 65)) | (1 << (CSharpParser.UNCHECKED - 65)) | (1 << (CSharpParser.USHORT - 65)) | (1 << (CSharpParser.VAR - 65)) | (1 << (CSharpParser.VOID - 65)) | (1 << (CSharpParser.WHEN - 65)) | (1 << (CSharpParser.WHERE - 65)) | (1 << (CSharpParser.YIELD - 65)) | (1 << (CSharpParser.IDENTIFIER - 65)) | (1 << (CSharpParser.LITERAL_ACCESS - 65)) | (1 << (CSharpParser.INTEGER_LITERAL - 65)) | (1 << (CSharpParser.HEX_INTEGER_LITERAL - 65)) | (1 << (CSharpParser.REAL_LITERAL - 65)) | (1 << (CSharpParser.CHARACTER_LITERAL - 65)) | (1 << (CSharpParser.REGULAR_STRING - 65)) | (1 << (CSharpParser.VERBATIUM_STRING - 65)) | (1 << (CSharpParser.INTERPOLATED_REGULAR_STRING_START - 65)) | (1 << (CSharpParser.INTERPOLATED_VERBATIUM_STRING_START - 65)) | (1 << (CSharpParser.OPEN_PARENS - 65)))) != 0) or ((((_la - 132)) & ~0x3f) == 0 and ((1 << (_la - 132)) & ((1 << (CSharpParser.PLUS - 132)) | (1 << (CSharpParser.MINUS - 132)) | (1 << (CSharpParser.STAR - 132)) | (1 << (CSharpParser.AMP - 132)) | (1 << (CSharpParser.BANG - 132)) | (1 << (CSharpParser.TILDE - 132)) | (1 << (CSharpParser.OP_INC - 132)) | (1 << (CSharpParser.OP_DEC - 132)))) != 0):
                self.state = 2366
                self.argument_list()


            self.state = 2369
            self.match(CSharpParser.CLOSE_PARENS)
            self.state = 2371
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==CSharpParser.OPEN_BRACE:
                self.state = 2370
                self.object_or_collection_initializer()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Documented_itemContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SINGLE_LINE_DOC_COMMENT(self):
            return self.getToken(CSharpParser.SINGLE_LINE_DOC_COMMENT, 0)

        def SINGLE_LINE_COMMENT(self):
            return self.getToken(CSharpParser.SINGLE_LINE_COMMENT, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_documented_item

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDocumented_item" ):
                listener.enterDocumented_item(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDocumented_item" ):
                listener.exitDocumented_item(self)




    def documented_item(self):

        localctx = CSharpParser.Documented_itemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 402, self.RULE_documented_item)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2373
            _la = self._input.LA(1)
            if not(_la==CSharpParser.SINGLE_LINE_DOC_COMMENT or _la==CSharpParser.SINGLE_LINE_COMMENT):
                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 IdentifierContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(CSharpParser.IDENTIFIER, 0)

        def ADD(self):
            return self.getToken(CSharpParser.ADD, 0)

        def ALIAS(self):
            return self.getToken(CSharpParser.ALIAS, 0)

        def ARGLIST(self):
            return self.getToken(CSharpParser.ARGLIST, 0)

        def ASCENDING(self):
            return self.getToken(CSharpParser.ASCENDING, 0)

        def ASYNC(self):
            return self.getToken(CSharpParser.ASYNC, 0)

        def AWAIT(self):
            return self.getToken(CSharpParser.AWAIT, 0)

        def BY(self):
            return self.getToken(CSharpParser.BY, 0)

        def DESCENDING(self):
            return self.getToken(CSharpParser.DESCENDING, 0)

        def DYNAMIC(self):
            return self.getToken(CSharpParser.DYNAMIC, 0)

        def EQUALS(self):
            return self.getToken(CSharpParser.EQUALS, 0)

        def FROM(self):
            return self.getToken(CSharpParser.FROM, 0)

        def GET(self):
            return self.getToken(CSharpParser.GET, 0)

        def GROUP(self):
            return self.getToken(CSharpParser.GROUP, 0)

        def INTO(self):
            return self.getToken(CSharpParser.INTO, 0)

        def JOIN(self):
            return self.getToken(CSharpParser.JOIN, 0)

        def LET(self):
            return self.getToken(CSharpParser.LET, 0)

        def NAMEOF(self):
            return self.getToken(CSharpParser.NAMEOF, 0)

        def ON(self):
            return self.getToken(CSharpParser.ON, 0)

        def ORDERBY(self):
            return self.getToken(CSharpParser.ORDERBY, 0)

        def PARTIAL(self):
            return self.getToken(CSharpParser.PARTIAL, 0)

        def REMOVE(self):
            return self.getToken(CSharpParser.REMOVE, 0)

        def SELECT(self):
            return self.getToken(CSharpParser.SELECT, 0)

        def SET(self):
            return self.getToken(CSharpParser.SET, 0)

        def VAR(self):
            return self.getToken(CSharpParser.VAR, 0)

        def WHEN(self):
            return self.getToken(CSharpParser.WHEN, 0)

        def WHERE(self):
            return self.getToken(CSharpParser.WHERE, 0)

        def YIELD(self):
            return self.getToken(CSharpParser.YIELD, 0)

        def getRuleIndex(self):
            return CSharpParser.RULE_identifier

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIdentifier" ):
                listener.enterIdentifier(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIdentifier" ):
                listener.exitIdentifier(self)




    def identifier(self):

        localctx = CSharpParser.IdentifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 404, self.RULE_identifier)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 2375
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ADD) | (1 << CSharpParser.ALIAS) | (1 << CSharpParser.ARGLIST) | (1 << CSharpParser.ASCENDING) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.AWAIT) | (1 << CSharpParser.BY) | (1 << CSharpParser.DESCENDING) | (1 << CSharpParser.DYNAMIC) | (1 << CSharpParser.EQUALS) | (1 << CSharpParser.FROM) | (1 << CSharpParser.GET) | (1 << CSharpParser.GROUP) | (1 << CSharpParser.INTO) | (1 << CSharpParser.JOIN) | (1 << CSharpParser.LET) | (1 << CSharpParser.NAMEOF))) != 0) or ((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (CSharpParser.ON - 68)) | (1 << (CSharpParser.ORDERBY - 68)) | (1 << (CSharpParser.PARTIAL - 68)) | (1 << (CSharpParser.REMOVE - 68)) | (1 << (CSharpParser.SELECT - 68)) | (1 << (CSharpParser.SET - 68)) | (1 << (CSharpParser.VAR - 68)) | (1 << (CSharpParser.WHEN - 68)) | (1 << (CSharpParser.WHERE - 68)) | (1 << (CSharpParser.YIELD - 68)) | (1 << (CSharpParser.IDENTIFIER - 68)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[171] = self.right_arrow_sempred
        self._predicates[172] = self.right_shift_sempred
        self._predicates[173] = self.right_shift_assignment_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def right_arrow_sempred(self, localctx:Right_arrowContext, predIndex:int):
            if predIndex == 0:
                return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)
         

    def right_shift_sempred(self, localctx:Right_shiftContext, predIndex:int):
            if predIndex == 1:
                return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)
         

    def right_shift_assignment_sempred(self, localctx:Right_shift_assignmentContext, predIndex:int):
            if predIndex == 2:
                return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)
         




