CSharpTestParser.java

// Generated from org/egothor/methodatlas/discovery/dotnet/parser/CSharpTest.g4 by ANTLR 4.13.2
package org.egothor.methodatlas.discovery.dotnet.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"})
public class CSharpTestParser extends Parser {
	static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		ABSTRACT=1, ALIAS=2, AS=3, ASSEMBLY=4, ASYNC=5, BASE=6, BREAK=7, BY=8, 
		CASE=9, CATCH=10, CHECKED=11, CLASS=12, CONST=13, CONTINUE=14, DEFAULT=15, 
		DELEGATE=16, DO=17, ELSE=18, ENUM=19, EVENT=20, EXPLICIT=21, EXTERN=22, 
		FALSE=23, FILE=24, FINALLY=25, FIXED=26, FOR=27, FOREACH=28, FROM=29, 
		GET=30, GLOBAL=31, GOTO=32, GROUP=33, IF=34, IMPLICIT=35, IN=36, INIT=37, 
		INTERFACE=38, INTERNAL=39, INTO=40, IS=41, JOIN=42, LET=43, LOCK=44, MODULE=45, 
		NAMEOF=46, NAMESPACE=47, NEW=48, NOTNULL=49, NULL=50, ON=51, OPERATOR=52, 
		ORDERBY=53, OUT=54, OVERRIDE=55, PARAMS=56, PARTIAL=57, PRIVATE=58, PROTECTED=59, 
		PUBLIC=60, READONLY=61, RECORD=62, REF=63, REMOVE=64, REQUIRED=65, RETURN=66, 
		SCOPED=67, SEALED=68, SELECT=69, SET=70, STATIC=71, STRUCT=72, SWITCH=73, 
		THIS=74, THROW=75, TRUE=76, TRY=77, TYPEOF=78, UNMANAGED=79, UNSAFE=80, 
		USING=81, VALUE=82, VIRTUAL=83, VOID=84, VOLATILE=85, WHERE=86, WHILE=87, 
		WITH=88, YIELD=89, BOOL=90, BYTE=91, CHAR_KW=92, DECIMAL=93, DOUBLE_KW=94, 
		DYNAMIC=95, FLOAT_KW=96, INT=97, LONG=98, OBJECT_KW=99, SBYTE=100, SHORT=101, 
		STRING_KW=102, UINT=103, ULONG=104, USHORT=105, VAR=106, LBRACE=107, RBRACE=108, 
		LBRACKET=109, RBRACKET=110, LPAREN=111, RPAREN=112, SEMI=113, COMMA=114, 
		DOT=115, FATARROW=116, ARROW=117, TILDE=118, QUESTION=119, COLON=120, 
		DOUBLE_COLON=121, EQ=122, EQEQ=123, NEQ=124, LT=125, GT=126, LTE=127, 
		GTE=128, PLUS=129, MINUS=130, STAR=131, DIV=132, MOD=133, AMP=134, PIPE=135, 
		CARET=136, BANG=137, PLUSPLUS=138, MINUSMINUS=139, ANDAND=140, OROR=141, 
		NULL_COND=142, NULL_COAL=143, NULL_COALEQ=144, PLUSEQ=145, MINUSEQ=146, 
		STAREQ=147, DIVEQ=148, MODEQ=149, AMPEQ=150, PIPEEQ=151, CARETEQ=152, 
		AT_SIGN=153, HASH=154, STRING_LITERAL=155, VERBATIM_STRING=156, RAW_STRING=157, 
		INTERPOLATED_STRING=158, CHAR_LITERAL=159, INTEGER_LITERAL=160, REAL_LITERAL=161, 
		BOM=162, IDENTIFIER=163, LINE_COMMENT=164, BLOCK_COMMENT=165, PREPROCESSOR=166, 
		WS=167;
	public static final int
		RULE_compilationUnit = 0, RULE_externalAliasDirective = 1, RULE_usingDirective = 2, 
		RULE_usingTypeName = 3, RULE_globalAttributeSection = 4, RULE_fileScopedNamespaceDeclaration = 5, 
		RULE_member = 6, RULE_namespaceDeclaration = 7, RULE_typeDeclaration = 8, 
		RULE_typeKwd = 9, RULE_enumDeclaration = 10, RULE_enumBodyContent = 11, 
		RULE_typeMember = 12, RULE_methodDeclaration = 13, RULE_constructorDeclaration = 14, 
		RULE_constructorInitializer = 15, RULE_destructorDeclaration = 16, RULE_propertyOrFieldDeclaration = 17, 
		RULE_propertyOrFieldBody = 18, RULE_operatorDeclaration = 19, RULE_overloadableOperator = 20, 
		RULE_conversionDeclaration = 21, RULE_eventDeclaration = 22, RULE_delegateDeclaration = 23, 
		RULE_indexerDeclaration = 24, RULE_returnType = 25, RULE_type = 26, RULE_typeAtom = 27, 
		RULE_primitiveTypeKwd = 28, RULE_tupleElement = 29, RULE_typeRankSuffix = 30, 
		RULE_typeArguments = 31, RULE_typeArgument = 32, RULE_typeParameterList = 33, 
		RULE_typeParameter = 34, RULE_typeList = 35, RULE_typeBaseList = 36, RULE_typeBase = 37, 
		RULE_typeConstraintClause = 38, RULE_typeConstraintList = 39, RULE_typeConstraint = 40, 
		RULE_memberName = 41, RULE_qualifiedName = 42, RULE_identifier = 43, RULE_memberBody = 44, 
		RULE_block = 45, RULE_blockContent = 46, RULE_bodyContent = 47, RULE_balancedContent = 48, 
		RULE_attributeSection = 49, RULE_attributeTarget = 50, RULE_attributeList = 51, 
		RULE_attribute = 52, RULE_attributeArgs = 53, RULE_attributeArg = 54, 
		RULE_attributeValue = 55, RULE_stringLiteral = 56, RULE_parameterList = 57, 
		RULE_parameter = 58, RULE_parameterModifier = 59, RULE_paramDefault = 60, 
		RULE_argumentList = 61, RULE_argument = 62, RULE_modifier = 63;
	private static String[] makeRuleNames() {
		return new String[] {
			"compilationUnit", "externalAliasDirective", "usingDirective", "usingTypeName", 
			"globalAttributeSection", "fileScopedNamespaceDeclaration", "member", 
			"namespaceDeclaration", "typeDeclaration", "typeKwd", "enumDeclaration", 
			"enumBodyContent", "typeMember", "methodDeclaration", "constructorDeclaration", 
			"constructorInitializer", "destructorDeclaration", "propertyOrFieldDeclaration", 
			"propertyOrFieldBody", "operatorDeclaration", "overloadableOperator", 
			"conversionDeclaration", "eventDeclaration", "delegateDeclaration", "indexerDeclaration", 
			"returnType", "type", "typeAtom", "primitiveTypeKwd", "tupleElement", 
			"typeRankSuffix", "typeArguments", "typeArgument", "typeParameterList", 
			"typeParameter", "typeList", "typeBaseList", "typeBase", "typeConstraintClause", 
			"typeConstraintList", "typeConstraint", "memberName", "qualifiedName", 
			"identifier", "memberBody", "block", "blockContent", "bodyContent", "balancedContent", 
			"attributeSection", "attributeTarget", "attributeList", "attribute", 
			"attributeArgs", "attributeArg", "attributeValue", "stringLiteral", "parameterList", 
			"parameter", "parameterModifier", "paramDefault", "argumentList", "argument", 
			"modifier"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'abstract'", "'alias'", "'as'", "'assembly'", "'async'", "'base'", 
			"'break'", "'by'", "'case'", "'catch'", "'checked'", "'class'", "'const'", 
			"'continue'", "'default'", "'delegate'", "'do'", "'else'", "'enum'", 
			"'event'", "'explicit'", "'extern'", "'false'", "'file'", "'finally'", 
			"'fixed'", "'for'", "'foreach'", "'from'", "'get'", "'global'", "'goto'", 
			"'group'", "'if'", "'implicit'", "'in'", "'init'", "'interface'", "'internal'", 
			"'into'", "'is'", "'join'", "'let'", "'lock'", "'module'", "'nameof'", 
			"'namespace'", "'new'", "'notnull'", "'null'", "'on'", "'operator'", 
			"'orderby'", "'out'", "'override'", "'params'", "'partial'", "'private'", 
			"'protected'", "'public'", "'readonly'", "'record'", "'ref'", "'remove'", 
			"'required'", "'return'", "'scoped'", "'sealed'", "'select'", "'set'", 
			"'static'", "'struct'", "'switch'", "'this'", "'throw'", "'true'", "'try'", 
			"'typeof'", "'unmanaged'", "'unsafe'", "'using'", "'value'", "'virtual'", 
			"'void'", "'volatile'", "'where'", "'while'", "'with'", "'yield'", "'bool'", 
			"'byte'", "'char'", "'decimal'", "'double'", "'dynamic'", "'float'", 
			"'int'", "'long'", "'object'", "'sbyte'", "'short'", "'string'", "'uint'", 
			"'ulong'", "'ushort'", "'var'", "'{'", "'}'", "'['", "']'", "'('", "')'", 
			"';'", "','", "'.'", "'=>'", "'->'", "'~'", "'?'", "':'", "'::'", "'='", 
			"'=='", "'!='", "'<'", "'>'", "'<='", "'>='", "'+'", "'-'", "'*'", "'/'", 
			"'%'", "'&'", "'|'", "'^'", "'!'", "'++'", "'--'", "'&&'", "'||'", "'?.'", 
			"'??'", "'??='", "'+='", "'-='", "'*='", "'/='", "'%='", "'&='", "'|='", 
			"'^='", "'@'", "'#'", null, null, null, null, null, null, null, "'\\uFEFF'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "ABSTRACT", "ALIAS", "AS", "ASSEMBLY", "ASYNC", "BASE", "BREAK", 
			"BY", "CASE", "CATCH", "CHECKED", "CLASS", "CONST", "CONTINUE", "DEFAULT", 
			"DELEGATE", "DO", "ELSE", "ENUM", "EVENT", "EXPLICIT", "EXTERN", "FALSE", 
			"FILE", "FINALLY", "FIXED", "FOR", "FOREACH", "FROM", "GET", "GLOBAL", 
			"GOTO", "GROUP", "IF", "IMPLICIT", "IN", "INIT", "INTERFACE", "INTERNAL", 
			"INTO", "IS", "JOIN", "LET", "LOCK", "MODULE", "NAMEOF", "NAMESPACE", 
			"NEW", "NOTNULL", "NULL", "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", 
			"PARAMS", "PARTIAL", "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "RECORD", 
			"REF", "REMOVE", "REQUIRED", "RETURN", "SCOPED", "SEALED", "SELECT", 
			"SET", "STATIC", "STRUCT", "SWITCH", "THIS", "THROW", "TRUE", "TRY", 
			"TYPEOF", "UNMANAGED", "UNSAFE", "USING", "VALUE", "VIRTUAL", "VOID", 
			"VOLATILE", "WHERE", "WHILE", "WITH", "YIELD", "BOOL", "BYTE", "CHAR_KW", 
			"DECIMAL", "DOUBLE_KW", "DYNAMIC", "FLOAT_KW", "INT", "LONG", "OBJECT_KW", 
			"SBYTE", "SHORT", "STRING_KW", "UINT", "ULONG", "USHORT", "VAR", "LBRACE", 
			"RBRACE", "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "SEMI", "COMMA", 
			"DOT", "FATARROW", "ARROW", "TILDE", "QUESTION", "COLON", "DOUBLE_COLON", 
			"EQ", "EQEQ", "NEQ", "LT", "GT", "LTE", "GTE", "PLUS", "MINUS", "STAR", 
			"DIV", "MOD", "AMP", "PIPE", "CARET", "BANG", "PLUSPLUS", "MINUSMINUS", 
			"ANDAND", "OROR", "NULL_COND", "NULL_COAL", "NULL_COALEQ", "PLUSEQ", 
			"MINUSEQ", "STAREQ", "DIVEQ", "MODEQ", "AMPEQ", "PIPEEQ", "CARETEQ", 
			"AT_SIGN", "HASH", "STRING_LITERAL", "VERBATIM_STRING", "RAW_STRING", 
			"INTERPOLATED_STRING", "CHAR_LITERAL", "INTEGER_LITERAL", "REAL_LITERAL", 
			"BOM", "IDENTIFIER", "LINE_COMMENT", "BLOCK_COMMENT", "PREPROCESSOR", 
			"WS"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "CSharpTest.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public CSharpTestParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	@SuppressWarnings("CheckReturnValue")
	public static class CompilationUnitContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(CSharpTestParser.EOF, 0); }
		public FileScopedNamespaceDeclarationContext fileScopedNamespaceDeclaration() {
			return getRuleContext(FileScopedNamespaceDeclarationContext.class,0);
		}
		public List<ExternalAliasDirectiveContext> externalAliasDirective() {
			return getRuleContexts(ExternalAliasDirectiveContext.class);
		}
		public ExternalAliasDirectiveContext externalAliasDirective(int i) {
			return getRuleContext(ExternalAliasDirectiveContext.class,i);
		}
		public List<UsingDirectiveContext> usingDirective() {
			return getRuleContexts(UsingDirectiveContext.class);
		}
		public UsingDirectiveContext usingDirective(int i) {
			return getRuleContext(UsingDirectiveContext.class,i);
		}
		public List<GlobalAttributeSectionContext> globalAttributeSection() {
			return getRuleContexts(GlobalAttributeSectionContext.class);
		}
		public GlobalAttributeSectionContext globalAttributeSection(int i) {
			return getRuleContext(GlobalAttributeSectionContext.class,i);
		}
		public List<MemberContext> member() {
			return getRuleContexts(MemberContext.class);
		}
		public MemberContext member(int i) {
			return getRuleContext(MemberContext.class,i);
		}
		public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_compilationUnit; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitCompilationUnit(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CompilationUnitContext compilationUnit() throws RecognitionException {
		CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_compilationUnit);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(131);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(128);
					externalAliasDirective();
					}
					} 
				}
				setState(133);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
			}
			setState(137);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==GLOBAL || _la==USING) {
				{
				{
				setState(134);
				usingDirective();
				}
				}
				setState(139);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(143);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(140);
					globalAttributeSection();
					}
					} 
				}
				setState(145);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
			}
			setState(153);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
			case 1:
				{
				setState(146);
				fileScopedNamespaceDeclaration();
				}
				break;
			case 2:
				{
				setState(150);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 9115708682985345058L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 17592187388105L) != 0)) {
					{
					{
					setState(147);
					member();
					}
					}
					setState(152);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			}
			setState(155);
			match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ExternalAliasDirectiveContext extends ParserRuleContext {
		public TerminalNode EXTERN() { return getToken(CSharpTestParser.EXTERN, 0); }
		public TerminalNode ALIAS() { return getToken(CSharpTestParser.ALIAS, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public ExternalAliasDirectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_externalAliasDirective; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitExternalAliasDirective(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExternalAliasDirectiveContext externalAliasDirective() throws RecognitionException {
		ExternalAliasDirectiveContext _localctx = new ExternalAliasDirectiveContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_externalAliasDirective);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(157);
			match(EXTERN);
			setState(158);
			match(ALIAS);
			setState(159);
			identifier();
			setState(160);
			match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UsingDirectiveContext extends ParserRuleContext {
		public TerminalNode USING() { return getToken(CSharpTestParser.USING, 0); }
		public UsingTypeNameContext usingTypeName() {
			return getRuleContext(UsingTypeNameContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public TerminalNode GLOBAL() { return getToken(CSharpTestParser.GLOBAL, 0); }
		public TerminalNode STATIC() { return getToken(CSharpTestParser.STATIC, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode EQ() { return getToken(CSharpTestParser.EQ, 0); }
		public UsingDirectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingDirective; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitUsingDirective(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UsingDirectiveContext usingDirective() throws RecognitionException {
		UsingDirectiveContext _localctx = new UsingDirectiveContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_usingDirective);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(163);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==GLOBAL) {
				{
				setState(162);
				match(GLOBAL);
				}
			}

			setState(165);
			match(USING);
			setState(167);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==STATIC) {
				{
				setState(166);
				match(STATIC);
				}
			}

			setState(172);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				{
				setState(169);
				identifier();
				setState(170);
				match(EQ);
				}
				break;
			}
			setState(174);
			usingTypeName();
			setState(175);
			match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class UsingTypeNameContext extends ParserRuleContext {
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public TypeArgumentsContext typeArguments() {
			return getRuleContext(TypeArgumentsContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public List<TupleElementContext> tupleElement() {
			return getRuleContexts(TupleElementContext.class);
		}
		public TupleElementContext tupleElement(int i) {
			return getRuleContext(TupleElementContext.class,i);
		}
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public UsingTypeNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_usingTypeName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitUsingTypeName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final UsingTypeNameContext usingTypeName() throws RecognitionException {
		UsingTypeNameContext _localctx = new UsingTypeNameContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_usingTypeName);
		int _la;
		try {
			setState(191);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ALIAS:
			case ASYNC:
			case BY:
			case DEFAULT:
			case FILE:
			case FROM:
			case GET:
			case GLOBAL:
			case GROUP:
			case INIT:
			case INTO:
			case JOIN:
			case LET:
			case NAMEOF:
			case NOTNULL:
			case ON:
			case ORDERBY:
			case PARTIAL:
			case RECORD:
			case REMOVE:
			case SCOPED:
			case SELECT:
			case SET:
			case UNMANAGED:
			case VALUE:
			case WHERE:
			case WITH:
			case YIELD:
			case DYNAMIC:
			case VAR:
			case IDENTIFIER:
				enterOuterAlt(_localctx, 1);
				{
				setState(177);
				qualifiedName();
				setState(179);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LT) {
					{
					setState(178);
					typeArguments();
					}
				}

				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 2);
				{
				setState(181);
				match(LPAREN);
				setState(182);
				tupleElement();
				setState(185); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(183);
					match(COMMA);
					setState(184);
					tupleElement();
					}
					}
					setState(187); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==COMMA );
				setState(189);
				match(RPAREN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class GlobalAttributeSectionContext extends ParserRuleContext {
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public AttributeListContext attributeList() {
			return getRuleContext(AttributeListContext.class,0);
		}
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public TerminalNode ASSEMBLY() { return getToken(CSharpTestParser.ASSEMBLY, 0); }
		public TerminalNode MODULE() { return getToken(CSharpTestParser.MODULE, 0); }
		public GlobalAttributeSectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_globalAttributeSection; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitGlobalAttributeSection(this);
			else return visitor.visitChildren(this);
		}
	}

	public final GlobalAttributeSectionContext globalAttributeSection() throws RecognitionException {
		GlobalAttributeSectionContext _localctx = new GlobalAttributeSectionContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_globalAttributeSection);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(193);
			match(LBRACKET);
			setState(194);
			_la = _input.LA(1);
			if ( !(_la==ASSEMBLY || _la==MODULE) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(195);
			match(COLON);
			setState(196);
			attributeList();
			setState(197);
			match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class FileScopedNamespaceDeclarationContext extends ParserRuleContext {
		public TerminalNode NAMESPACE() { return getToken(CSharpTestParser.NAMESPACE, 0); }
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<MemberContext> member() {
			return getRuleContexts(MemberContext.class);
		}
		public MemberContext member(int i) {
			return getRuleContext(MemberContext.class,i);
		}
		public FileScopedNamespaceDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_fileScopedNamespaceDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitFileScopedNamespaceDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FileScopedNamespaceDeclarationContext fileScopedNamespaceDeclaration() throws RecognitionException {
		FileScopedNamespaceDeclarationContext _localctx = new FileScopedNamespaceDeclarationContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_fileScopedNamespaceDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(199);
			match(NAMESPACE);
			setState(200);
			qualifiedName();
			setState(201);
			match(SEMI);
			setState(205);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 9115708682985345058L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 17592187388105L) != 0)) {
				{
				{
				setState(202);
				member();
				}
				}
				setState(207);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberContext extends ParserRuleContext {
		public NamespaceDeclarationContext namespaceDeclaration() {
			return getRuleContext(NamespaceDeclarationContext.class,0);
		}
		public TypeDeclarationContext typeDeclaration() {
			return getRuleContext(TypeDeclarationContext.class,0);
		}
		public EnumDeclarationContext enumDeclaration() {
			return getRuleContext(EnumDeclarationContext.class,0);
		}
		public DelegateDeclarationContext delegateDeclaration() {
			return getRuleContext(DelegateDeclarationContext.class,0);
		}
		public MemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_member; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MemberContext member() throws RecognitionException {
		MemberContext _localctx = new MemberContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_member);
		try {
			setState(212);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(208);
				namespaceDeclaration();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(209);
				typeDeclaration();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(210);
				enumDeclaration();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(211);
				delegateDeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class NamespaceDeclarationContext extends ParserRuleContext {
		public TerminalNode NAMESPACE() { return getToken(CSharpTestParser.NAMESPACE, 0); }
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public List<UsingDirectiveContext> usingDirective() {
			return getRuleContexts(UsingDirectiveContext.class);
		}
		public UsingDirectiveContext usingDirective(int i) {
			return getRuleContext(UsingDirectiveContext.class,i);
		}
		public List<MemberContext> member() {
			return getRuleContexts(MemberContext.class);
		}
		public MemberContext member(int i) {
			return getRuleContext(MemberContext.class,i);
		}
		public NamespaceDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_namespaceDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitNamespaceDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NamespaceDeclarationContext namespaceDeclaration() throws RecognitionException {
		NamespaceDeclarationContext _localctx = new NamespaceDeclarationContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_namespaceDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(214);
			match(NAMESPACE);
			setState(215);
			qualifiedName();
			setState(216);
			match(LBRACE);
			setState(220);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==GLOBAL || _la==USING) {
				{
				{
				setState(217);
				usingDirective();
				}
				}
				setState(222);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(226);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 9115708682985345058L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 17592187388105L) != 0)) {
				{
				{
				setState(223);
				member();
				}
				}
				setState(228);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(229);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeDeclarationContext extends ParserRuleContext {
		public TypeKwdContext typeKwd() {
			return getRuleContext(TypeKwdContext.class,0);
		}
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public TypeParameterListContext typeParameterList() {
			return getRuleContext(TypeParameterListContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public TypeBaseListContext typeBaseList() {
			return getRuleContext(TypeBaseListContext.class,0);
		}
		public List<TypeConstraintClauseContext> typeConstraintClause() {
			return getRuleContexts(TypeConstraintClauseContext.class);
		}
		public TypeConstraintClauseContext typeConstraintClause(int i) {
			return getRuleContext(TypeConstraintClauseContext.class,i);
		}
		public List<TypeMemberContext> typeMember() {
			return getRuleContexts(TypeMemberContext.class);
		}
		public TypeMemberContext typeMember(int i) {
			return getRuleContext(TypeMemberContext.class,i);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
		TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_typeDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(234);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(231);
				attributeSection();
				}
				}
				setState(236);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(240);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) {
				{
				{
				setState(237);
				modifier();
				}
				}
				setState(242);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(243);
			typeKwd();
			setState(244);
			identifier();
			setState(246);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LT) {
				{
				setState(245);
				typeParameterList();
				}
			}

			setState(253);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LPAREN) {
				{
				setState(248);
				match(LPAREN);
				setState(250);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
					{
					setState(249);
					parameterList();
					}
				}

				setState(252);
				match(RPAREN);
				}
			}

			setState(257);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(255);
				match(COLON);
				setState(256);
				typeBaseList();
				}
			}

			setState(262);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==WHERE) {
				{
				{
				setState(259);
				typeConstraintClause();
				}
				}
				setState(264);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(274);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				{
				setState(265);
				match(LBRACE);
				setState(269);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 9127474741064085798L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 18199116454396411L) != 0) || _la==IDENTIFIER) {
					{
					{
					setState(266);
					typeMember();
					}
					}
					setState(271);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(272);
				match(RBRACE);
				}
				break;
			case SEMI:
				{
				setState(273);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeKwdContext extends ParserRuleContext {
		public TerminalNode CLASS() { return getToken(CSharpTestParser.CLASS, 0); }
		public TerminalNode INTERFACE() { return getToken(CSharpTestParser.INTERFACE, 0); }
		public TerminalNode STRUCT() { return getToken(CSharpTestParser.STRUCT, 0); }
		public TerminalNode RECORD() { return getToken(CSharpTestParser.RECORD, 0); }
		public TypeKwdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeKwd; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeKwd(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeKwdContext typeKwd() throws RecognitionException {
		TypeKwdContext _localctx = new TypeKwdContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_typeKwd);
		int _la;
		try {
			setState(283);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case CLASS:
				enterOuterAlt(_localctx, 1);
				{
				setState(276);
				match(CLASS);
				}
				break;
			case INTERFACE:
				enterOuterAlt(_localctx, 2);
				{
				setState(277);
				match(INTERFACE);
				}
				break;
			case STRUCT:
				enterOuterAlt(_localctx, 3);
				{
				setState(278);
				match(STRUCT);
				}
				break;
			case RECORD:
				enterOuterAlt(_localctx, 4);
				{
				setState(279);
				match(RECORD);
				setState(281);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==CLASS || _la==STRUCT) {
					{
					setState(280);
					_la = _input.LA(1);
					if ( !(_la==CLASS || _la==STRUCT) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					}
				}

				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumDeclarationContext extends ParserRuleContext {
		public TerminalNode ENUM() { return getToken(CSharpTestParser.ENUM, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public List<EnumBodyContentContext> enumBodyContent() {
			return getRuleContexts(EnumBodyContentContext.class);
		}
		public EnumBodyContentContext enumBodyContent(int i) {
			return getRuleContext(EnumBodyContentContext.class,i);
		}
		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitEnumDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
		EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_enumDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(288);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(285);
				attributeSection();
				}
				}
				setState(290);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(294);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) {
				{
				{
				setState(291);
				modifier();
				}
				}
				setState(296);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(297);
			match(ENUM);
			setState(298);
			identifier();
			setState(301);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(299);
				match(COLON);
				setState(300);
				type();
				}
			}

			setState(303);
			match(LBRACE);
			setState(307);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -17592186044417L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
				{
				{
				setState(304);
				enumBodyContent();
				}
				}
				setState(309);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(310);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EnumBodyContentContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public List<EnumBodyContentContext> enumBodyContent() {
			return getRuleContexts(EnumBodyContentContext.class);
		}
		public EnumBodyContentContext enumBodyContent(int i) {
			return getRuleContext(EnumBodyContentContext.class,i);
		}
		public EnumBodyContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_enumBodyContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitEnumBodyContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EnumBodyContentContext enumBodyContent() throws RecognitionException {
		EnumBodyContentContext _localctx = new EnumBodyContentContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_enumBodyContent);
		int _la;
		try {
			setState(321);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ABSTRACT:
			case ALIAS:
			case AS:
			case ASSEMBLY:
			case ASYNC:
			case BASE:
			case BREAK:
			case BY:
			case CASE:
			case CATCH:
			case CHECKED:
			case CLASS:
			case CONST:
			case CONTINUE:
			case DEFAULT:
			case DELEGATE:
			case DO:
			case ELSE:
			case ENUM:
			case EVENT:
			case EXPLICIT:
			case EXTERN:
			case FALSE:
			case FILE:
			case FINALLY:
			case FIXED:
			case FOR:
			case FOREACH:
			case FROM:
			case GET:
			case GLOBAL:
			case GOTO:
			case GROUP:
			case IF:
			case IMPLICIT:
			case IN:
			case INIT:
			case INTERFACE:
			case INTERNAL:
			case INTO:
			case IS:
			case JOIN:
			case LET:
			case LOCK:
			case MODULE:
			case NAMEOF:
			case NAMESPACE:
			case NEW:
			case NOTNULL:
			case NULL:
			case ON:
			case OPERATOR:
			case ORDERBY:
			case OUT:
			case OVERRIDE:
			case PARAMS:
			case PARTIAL:
			case PRIVATE:
			case PROTECTED:
			case PUBLIC:
			case READONLY:
			case RECORD:
			case REF:
			case REMOVE:
			case REQUIRED:
			case RETURN:
			case SCOPED:
			case SEALED:
			case SELECT:
			case SET:
			case STATIC:
			case STRUCT:
			case SWITCH:
			case THIS:
			case THROW:
			case TRUE:
			case TRY:
			case TYPEOF:
			case UNMANAGED:
			case UNSAFE:
			case USING:
			case VALUE:
			case VIRTUAL:
			case VOID:
			case VOLATILE:
			case WHERE:
			case WHILE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case LBRACKET:
			case RBRACKET:
			case LPAREN:
			case RPAREN:
			case SEMI:
			case COMMA:
			case DOT:
			case FATARROW:
			case ARROW:
			case TILDE:
			case QUESTION:
			case COLON:
			case DOUBLE_COLON:
			case EQ:
			case EQEQ:
			case NEQ:
			case LT:
			case GT:
			case LTE:
			case GTE:
			case PLUS:
			case MINUS:
			case STAR:
			case DIV:
			case MOD:
			case AMP:
			case PIPE:
			case CARET:
			case BANG:
			case PLUSPLUS:
			case MINUSMINUS:
			case ANDAND:
			case OROR:
			case NULL_COND:
			case NULL_COAL:
			case NULL_COALEQ:
			case PLUSEQ:
			case MINUSEQ:
			case STAREQ:
			case DIVEQ:
			case MODEQ:
			case AMPEQ:
			case PIPEEQ:
			case CARETEQ:
			case AT_SIGN:
			case HASH:
			case STRING_LITERAL:
			case VERBATIM_STRING:
			case RAW_STRING:
			case INTERPOLATED_STRING:
			case CHAR_LITERAL:
			case INTEGER_LITERAL:
			case REAL_LITERAL:
			case BOM:
			case IDENTIFIER:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case PREPROCESSOR:
			case WS:
				enterOuterAlt(_localctx, 1);
				{
				setState(312);
				_la = _input.LA(1);
				if ( _la <= 0 || (_la==LBRACE || _la==RBRACE) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			case LBRACE:
				enterOuterAlt(_localctx, 2);
				{
				setState(313);
				match(LBRACE);
				setState(317);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -17592186044417L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(314);
					enumBodyContent();
					}
					}
					setState(319);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(320);
				match(RBRACE);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeMemberContext extends ParserRuleContext {
		public TypeDeclarationContext typeDeclaration() {
			return getRuleContext(TypeDeclarationContext.class,0);
		}
		public EnumDeclarationContext enumDeclaration() {
			return getRuleContext(EnumDeclarationContext.class,0);
		}
		public DelegateDeclarationContext delegateDeclaration() {
			return getRuleContext(DelegateDeclarationContext.class,0);
		}
		public MethodDeclarationContext methodDeclaration() {
			return getRuleContext(MethodDeclarationContext.class,0);
		}
		public ConstructorDeclarationContext constructorDeclaration() {
			return getRuleContext(ConstructorDeclarationContext.class,0);
		}
		public DestructorDeclarationContext destructorDeclaration() {
			return getRuleContext(DestructorDeclarationContext.class,0);
		}
		public IndexerDeclarationContext indexerDeclaration() {
			return getRuleContext(IndexerDeclarationContext.class,0);
		}
		public PropertyOrFieldDeclarationContext propertyOrFieldDeclaration() {
			return getRuleContext(PropertyOrFieldDeclarationContext.class,0);
		}
		public OperatorDeclarationContext operatorDeclaration() {
			return getRuleContext(OperatorDeclarationContext.class,0);
		}
		public ConversionDeclarationContext conversionDeclaration() {
			return getRuleContext(ConversionDeclarationContext.class,0);
		}
		public EventDeclarationContext eventDeclaration() {
			return getRuleContext(EventDeclarationContext.class,0);
		}
		public TypeMemberContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeMember; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeMember(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeMemberContext typeMember() throws RecognitionException {
		TypeMemberContext _localctx = new TypeMemberContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_typeMember);
		try {
			setState(334);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(323);
				typeDeclaration();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(324);
				enumDeclaration();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(325);
				delegateDeclaration();
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(326);
				methodDeclaration();
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(327);
				constructorDeclaration();
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(328);
				destructorDeclaration();
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(329);
				indexerDeclaration();
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(330);
				propertyOrFieldDeclaration();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(331);
				operatorDeclaration();
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(332);
				conversionDeclaration();
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(333);
				eventDeclaration();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MethodDeclarationContext extends ParserRuleContext {
		public ReturnTypeContext returnType() {
			return getRuleContext(ReturnTypeContext.class,0);
		}
		public MemberNameContext memberName() {
			return getRuleContext(MemberNameContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public MemberBodyContext memberBody() {
			return getRuleContext(MemberBodyContext.class,0);
		}
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public TypeParameterListContext typeParameterList() {
			return getRuleContext(TypeParameterListContext.class,0);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public List<TypeConstraintClauseContext> typeConstraintClause() {
			return getRuleContexts(TypeConstraintClauseContext.class);
		}
		public TypeConstraintClauseContext typeConstraintClause(int i) {
			return getRuleContext(TypeConstraintClauseContext.class,i);
		}
		public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitMethodDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
		MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_methodDeclaration);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(339);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(336);
				attributeSection();
				}
				}
				setState(341);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(345);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(342);
					modifier();
					}
					} 
				}
				setState(347);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
			}
			setState(348);
			returnType();
			setState(349);
			memberName();
			setState(351);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LT) {
				{
				setState(350);
				typeParameterList();
				}
			}

			setState(353);
			match(LPAREN);
			setState(355);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
				{
				setState(354);
				parameterList();
				}
			}

			setState(357);
			match(RPAREN);
			setState(361);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==WHERE) {
				{
				{
				setState(358);
				typeConstraintClause();
				}
				}
				setState(363);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(364);
			memberBody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConstructorDeclarationContext extends ParserRuleContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode FATARROW() { return getToken(CSharpTestParser.FATARROW, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public ConstructorInitializerContext constructorInitializer() {
			return getRuleContext(ConstructorInitializerContext.class,0);
		}
		public List<BodyContentContext> bodyContent() {
			return getRuleContexts(BodyContentContext.class);
		}
		public BodyContentContext bodyContent(int i) {
			return getRuleContext(BodyContentContext.class,i);
		}
		public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitConstructorDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
		ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_constructorDeclaration);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(369);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(366);
				attributeSection();
				}
				}
				setState(371);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(375);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(372);
					modifier();
					}
					} 
				}
				setState(377);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
			}
			setState(378);
			identifier();
			setState(379);
			match(LPAREN);
			setState(381);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
				{
				setState(380);
				parameterList();
				}
			}

			setState(383);
			match(RPAREN);
			setState(385);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==COLON) {
				{
				setState(384);
				constructorInitializer();
				}
			}

			setState(396);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				{
				setState(387);
				block();
				}
				break;
			case FATARROW:
				{
				setState(388);
				match(FATARROW);
				setState(392);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(389);
						bodyContent();
						}
						} 
					}
					setState(394);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
				}
				setState(395);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConstructorInitializerContext extends ParserRuleContext {
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode BASE() { return getToken(CSharpTestParser.BASE, 0); }
		public TerminalNode THIS() { return getToken(CSharpTestParser.THIS, 0); }
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public ConstructorInitializerContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_constructorInitializer; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitConstructorInitializer(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConstructorInitializerContext constructorInitializer() throws RecognitionException {
		ConstructorInitializerContext _localctx = new ConstructorInitializerContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_constructorInitializer);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(398);
			match(COLON);
			setState(399);
			_la = _input.LA(1);
			if ( !(_la==BASE || _la==THIS) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(400);
			match(LPAREN);
			setState(404);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
				{
				{
				setState(401);
				balancedContent();
				}
				}
				setState(406);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(407);
			match(RPAREN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DestructorDeclarationContext extends ParserRuleContext {
		public TerminalNode TILDE() { return getToken(CSharpTestParser.TILDE, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public DestructorDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_destructorDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitDestructorDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DestructorDeclarationContext destructorDeclaration() throws RecognitionException {
		DestructorDeclarationContext _localctx = new DestructorDeclarationContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_destructorDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(412);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(409);
				attributeSection();
				}
				}
				setState(414);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(418);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) {
				{
				{
				setState(415);
				modifier();
				}
				}
				setState(420);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(421);
			match(TILDE);
			setState(422);
			identifier();
			setState(423);
			match(LPAREN);
			setState(424);
			match(RPAREN);
			setState(425);
			block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PropertyOrFieldDeclarationContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public MemberNameContext memberName() {
			return getRuleContext(MemberNameContext.class,0);
		}
		public PropertyOrFieldBodyContext propertyOrFieldBody() {
			return getRuleContext(PropertyOrFieldBodyContext.class,0);
		}
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public TerminalNode CONST() { return getToken(CSharpTestParser.CONST, 0); }
		public PropertyOrFieldDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_propertyOrFieldDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitPropertyOrFieldDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PropertyOrFieldDeclarationContext propertyOrFieldDeclaration() throws RecognitionException {
		PropertyOrFieldDeclarationContext _localctx = new PropertyOrFieldDeclarationContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_propertyOrFieldDeclaration);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(430);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(427);
				attributeSection();
				}
				}
				setState(432);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(436);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,48,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(433);
					modifier();
					}
					} 
				}
				setState(438);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,48,_ctx);
			}
			setState(440);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==CONST) {
				{
				setState(439);
				match(CONST);
				}
			}

			setState(442);
			type();
			setState(443);
			memberName();
			setState(444);
			propertyOrFieldBody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PropertyOrFieldBodyContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public List<BodyContentContext> bodyContent() {
			return getRuleContexts(BodyContentContext.class);
		}
		public BodyContentContext bodyContent(int i) {
			return getRuleContext(BodyContentContext.class,i);
		}
		public TerminalNode EQ() { return getToken(CSharpTestParser.EQ, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public TerminalNode FATARROW() { return getToken(CSharpTestParser.FATARROW, 0); }
		public PropertyOrFieldBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_propertyOrFieldBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitPropertyOrFieldBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PropertyOrFieldBodyContext propertyOrFieldBody() throws RecognitionException {
		PropertyOrFieldBodyContext _localctx = new PropertyOrFieldBodyContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_propertyOrFieldBody);
		int _la;
		try {
			int _alt;
			setState(482);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(446);
				match(LBRACE);
				setState(450);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(447);
					bodyContent();
					}
					}
					setState(452);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(453);
				match(RBRACE);
				setState(462);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==EQ) {
					{
					setState(454);
					match(EQ);
					setState(458);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
					while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
						if ( _alt==1 ) {
							{
							{
							setState(455);
							bodyContent();
							}
							} 
						}
						setState(460);
						_errHandler.sync(this);
						_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
					}
					setState(461);
					match(SEMI);
					}
				}

				}
				break;
			case FATARROW:
				enterOuterAlt(_localctx, 2);
				{
				setState(464);
				match(FATARROW);
				setState(468);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(465);
						bodyContent();
						}
						} 
					}
					setState(470);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,53,_ctx);
				}
				setState(471);
				match(SEMI);
				}
				break;
			case SEMI:
			case EQ:
				enterOuterAlt(_localctx, 3);
				{
				setState(479);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==EQ) {
					{
					setState(472);
					match(EQ);
					setState(476);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,54,_ctx);
					while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
						if ( _alt==1 ) {
							{
							{
							setState(473);
							bodyContent();
							}
							} 
						}
						setState(478);
						_errHandler.sync(this);
						_alt = getInterpreter().adaptivePredict(_input,54,_ctx);
					}
					}
				}

				setState(481);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OperatorDeclarationContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode OPERATOR() { return getToken(CSharpTestParser.OPERATOR, 0); }
		public OverloadableOperatorContext overloadableOperator() {
			return getRuleContext(OverloadableOperatorContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode FATARROW() { return getToken(CSharpTestParser.FATARROW, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public List<BodyContentContext> bodyContent() {
			return getRuleContexts(BodyContentContext.class);
		}
		public BodyContentContext bodyContent(int i) {
			return getRuleContext(BodyContentContext.class,i);
		}
		public OperatorDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_operatorDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitOperatorDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OperatorDeclarationContext operatorDeclaration() throws RecognitionException {
		OperatorDeclarationContext _localctx = new OperatorDeclarationContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_operatorDeclaration);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(487);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(484);
				attributeSection();
				}
				}
				setState(489);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(493);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(490);
					modifier();
					}
					} 
				}
				setState(495);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
			}
			setState(496);
			type();
			setState(497);
			match(OPERATOR);
			setState(498);
			overloadableOperator();
			setState(499);
			match(LPAREN);
			setState(501);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
				{
				setState(500);
				parameterList();
				}
			}

			setState(503);
			match(RPAREN);
			setState(513);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				{
				setState(504);
				block();
				}
				break;
			case FATARROW:
				{
				setState(505);
				match(FATARROW);
				setState(509);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(506);
						bodyContent();
						}
						} 
					}
					setState(511);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
				}
				setState(512);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class OverloadableOperatorContext extends ParserRuleContext {
		public TerminalNode PLUS() { return getToken(CSharpTestParser.PLUS, 0); }
		public TerminalNode MINUS() { return getToken(CSharpTestParser.MINUS, 0); }
		public TerminalNode STAR() { return getToken(CSharpTestParser.STAR, 0); }
		public TerminalNode DIV() { return getToken(CSharpTestParser.DIV, 0); }
		public TerminalNode MOD() { return getToken(CSharpTestParser.MOD, 0); }
		public TerminalNode AMP() { return getToken(CSharpTestParser.AMP, 0); }
		public TerminalNode PIPE() { return getToken(CSharpTestParser.PIPE, 0); }
		public TerminalNode CARET() { return getToken(CSharpTestParser.CARET, 0); }
		public TerminalNode BANG() { return getToken(CSharpTestParser.BANG, 0); }
		public TerminalNode TILDE() { return getToken(CSharpTestParser.TILDE, 0); }
		public TerminalNode PLUSPLUS() { return getToken(CSharpTestParser.PLUSPLUS, 0); }
		public TerminalNode MINUSMINUS() { return getToken(CSharpTestParser.MINUSMINUS, 0); }
		public List<TerminalNode> LT() { return getTokens(CSharpTestParser.LT); }
		public TerminalNode LT(int i) {
			return getToken(CSharpTestParser.LT, i);
		}
		public List<TerminalNode> GT() { return getTokens(CSharpTestParser.GT); }
		public TerminalNode GT(int i) {
			return getToken(CSharpTestParser.GT, i);
		}
		public TerminalNode LTE() { return getToken(CSharpTestParser.LTE, 0); }
		public TerminalNode GTE() { return getToken(CSharpTestParser.GTE, 0); }
		public TerminalNode EQEQ() { return getToken(CSharpTestParser.EQEQ, 0); }
		public TerminalNode NEQ() { return getToken(CSharpTestParser.NEQ, 0); }
		public TerminalNode TRUE() { return getToken(CSharpTestParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(CSharpTestParser.FALSE, 0); }
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public OverloadableOperatorContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_overloadableOperator; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitOverloadableOperator(this);
			else return visitor.visitChildren(this);
		}
	}

	public final OverloadableOperatorContext overloadableOperator() throws RecognitionException {
		OverloadableOperatorContext _localctx = new OverloadableOperatorContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_overloadableOperator);
		try {
			setState(541);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(515);
				match(PLUS);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(516);
				match(MINUS);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(517);
				match(STAR);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(518);
				match(DIV);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(519);
				match(MOD);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(520);
				match(AMP);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(521);
				match(PIPE);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(522);
				match(CARET);
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(523);
				match(BANG);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(524);
				match(TILDE);
				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(525);
				match(PLUSPLUS);
				}
				break;
			case 12:
				enterOuterAlt(_localctx, 12);
				{
				setState(526);
				match(MINUSMINUS);
				}
				break;
			case 13:
				enterOuterAlt(_localctx, 13);
				{
				setState(527);
				match(LT);
				}
				break;
			case 14:
				enterOuterAlt(_localctx, 14);
				{
				setState(528);
				match(GT);
				}
				break;
			case 15:
				enterOuterAlt(_localctx, 15);
				{
				setState(529);
				match(LTE);
				}
				break;
			case 16:
				enterOuterAlt(_localctx, 16);
				{
				setState(530);
				match(GTE);
				}
				break;
			case 17:
				enterOuterAlt(_localctx, 17);
				{
				setState(531);
				match(EQEQ);
				}
				break;
			case 18:
				enterOuterAlt(_localctx, 18);
				{
				setState(532);
				match(NEQ);
				}
				break;
			case 19:
				enterOuterAlt(_localctx, 19);
				{
				setState(533);
				match(LT);
				setState(534);
				match(LT);
				}
				break;
			case 20:
				enterOuterAlt(_localctx, 20);
				{
				setState(535);
				match(GT);
				setState(536);
				match(GT);
				}
				break;
			case 21:
				enterOuterAlt(_localctx, 21);
				{
				setState(537);
				match(TRUE);
				}
				break;
			case 22:
				enterOuterAlt(_localctx, 22);
				{
				setState(538);
				match(FALSE);
				}
				break;
			case 23:
				enterOuterAlt(_localctx, 23);
				{
				setState(539);
				match(LBRACKET);
				setState(540);
				match(RBRACKET);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ConversionDeclarationContext extends ParserRuleContext {
		public TerminalNode OPERATOR() { return getToken(CSharpTestParser.OPERATOR, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode EXPLICIT() { return getToken(CSharpTestParser.EXPLICIT, 0); }
		public TerminalNode IMPLICIT() { return getToken(CSharpTestParser.IMPLICIT, 0); }
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode FATARROW() { return getToken(CSharpTestParser.FATARROW, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public List<BodyContentContext> bodyContent() {
			return getRuleContexts(BodyContentContext.class);
		}
		public BodyContentContext bodyContent(int i) {
			return getRuleContext(BodyContentContext.class,i);
		}
		public ConversionDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conversionDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitConversionDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConversionDeclarationContext conversionDeclaration() throws RecognitionException {
		ConversionDeclarationContext _localctx = new ConversionDeclarationContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_conversionDeclaration);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(546);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(543);
				attributeSection();
				}
				}
				setState(548);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(552);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) {
				{
				{
				setState(549);
				modifier();
				}
				}
				setState(554);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(555);
			_la = _input.LA(1);
			if ( !(_la==EXPLICIT || _la==IMPLICIT) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(556);
			match(OPERATOR);
			setState(557);
			type();
			setState(558);
			match(LPAREN);
			setState(560);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
				{
				setState(559);
				parameterList();
				}
			}

			setState(562);
			match(RPAREN);
			setState(572);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				{
				setState(563);
				block();
				}
				break;
			case FATARROW:
				{
				setState(564);
				match(FATARROW);
				setState(568);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(565);
						bodyContent();
						}
						} 
					}
					setState(570);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
				}
				setState(571);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class EventDeclarationContext extends ParserRuleContext {
		public TerminalNode EVENT() { return getToken(CSharpTestParser.EVENT, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public MemberNameContext memberName() {
			return getRuleContext(MemberNameContext.class,0);
		}
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public List<BodyContentContext> bodyContent() {
			return getRuleContexts(BodyContentContext.class);
		}
		public BodyContentContext bodyContent(int i) {
			return getRuleContext(BodyContentContext.class,i);
		}
		public EventDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_eventDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitEventDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EventDeclarationContext eventDeclaration() throws RecognitionException {
		EventDeclarationContext _localctx = new EventDeclarationContext(_ctx, getState());
		enterRule(_localctx, 44, RULE_eventDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(577);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(574);
				attributeSection();
				}
				}
				setState(579);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(583);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) {
				{
				{
				setState(580);
				modifier();
				}
				}
				setState(585);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(586);
			match(EVENT);
			setState(587);
			type();
			setState(588);
			memberName();
			setState(598);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				{
				setState(589);
				match(LBRACE);
				setState(593);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(590);
					bodyContent();
					}
					}
					setState(595);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(596);
				match(RBRACE);
				}
				break;
			case SEMI:
				{
				setState(597);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class DelegateDeclarationContext extends ParserRuleContext {
		public TerminalNode DELEGATE() { return getToken(CSharpTestParser.DELEGATE, 0); }
		public ReturnTypeContext returnType() {
			return getRuleContext(ReturnTypeContext.class,0);
		}
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public TypeParameterListContext typeParameterList() {
			return getRuleContext(TypeParameterListContext.class,0);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public List<TypeConstraintClauseContext> typeConstraintClause() {
			return getRuleContexts(TypeConstraintClauseContext.class);
		}
		public TypeConstraintClauseContext typeConstraintClause(int i) {
			return getRuleContext(TypeConstraintClauseContext.class,i);
		}
		public DelegateDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_delegateDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitDelegateDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DelegateDeclarationContext delegateDeclaration() throws RecognitionException {
		DelegateDeclarationContext _localctx = new DelegateDeclarationContext(_ctx, getState());
		enterRule(_localctx, 46, RULE_delegateDeclaration);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(603);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(600);
				attributeSection();
				}
				}
				setState(605);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(609);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) {
				{
				{
				setState(606);
				modifier();
				}
				}
				setState(611);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(612);
			match(DELEGATE);
			setState(613);
			returnType();
			setState(614);
			identifier();
			setState(616);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LT) {
				{
				setState(615);
				typeParameterList();
				}
			}

			setState(618);
			match(LPAREN);
			setState(620);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
				{
				setState(619);
				parameterList();
				}
			}

			setState(622);
			match(RPAREN);
			setState(626);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==WHERE) {
				{
				{
				setState(623);
				typeConstraintClause();
				}
				}
				setState(628);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(629);
			match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IndexerDeclarationContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode THIS() { return getToken(CSharpTestParser.THIS, 0); }
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public PropertyOrFieldBodyContext propertyOrFieldBody() {
			return getRuleContext(PropertyOrFieldBodyContext.class,0);
		}
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ModifierContext> modifier() {
			return getRuleContexts(ModifierContext.class);
		}
		public ModifierContext modifier(int i) {
			return getRuleContext(ModifierContext.class,i);
		}
		public ParameterListContext parameterList() {
			return getRuleContext(ParameterListContext.class,0);
		}
		public IndexerDeclarationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_indexerDeclaration; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitIndexerDeclaration(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IndexerDeclarationContext indexerDeclaration() throws RecognitionException {
		IndexerDeclarationContext _localctx = new IndexerDeclarationContext(_ctx, getState());
		enterRule(_localctx, 48, RULE_indexerDeclaration);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(634);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(631);
				attributeSection();
				}
				}
				setState(636);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(640);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(637);
					modifier();
					}
					} 
				}
				setState(642);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
			}
			setState(643);
			type();
			setState(644);
			match(THIS);
			setState(645);
			match(LBRACKET);
			setState(647);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2059748998649970396L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 184717941179497L) != 0) || _la==IDENTIFIER) {
				{
				setState(646);
				parameterList();
				}
			}

			setState(649);
			match(RBRACKET);
			setState(650);
			propertyOrFieldBody();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ReturnTypeContext extends ParserRuleContext {
		public TerminalNode VOID() { return getToken(CSharpTestParser.VOID, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public ReturnTypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_returnType; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitReturnType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ReturnTypeContext returnType() throws RecognitionException {
		ReturnTypeContext _localctx = new ReturnTypeContext(_ctx, getState());
		enterRule(_localctx, 50, RULE_returnType);
		try {
			setState(654);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case VOID:
				enterOuterAlt(_localctx, 1);
				{
				setState(652);
				match(VOID);
				}
				break;
			case ALIAS:
			case ASYNC:
			case BY:
			case DEFAULT:
			case FILE:
			case FROM:
			case GET:
			case GLOBAL:
			case GROUP:
			case INIT:
			case INTO:
			case JOIN:
			case LET:
			case NAMEOF:
			case NOTNULL:
			case ON:
			case ORDERBY:
			case PARTIAL:
			case RECORD:
			case REMOVE:
			case SCOPED:
			case SELECT:
			case SET:
			case UNMANAGED:
			case VALUE:
			case WHERE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case LPAREN:
			case IDENTIFIER:
				enterOuterAlt(_localctx, 2);
				{
				setState(653);
				type();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeContext extends ParserRuleContext {
		public TypeAtomContext typeAtom() {
			return getRuleContext(TypeAtomContext.class,0);
		}
		public TypeArgumentsContext typeArguments() {
			return getRuleContext(TypeArgumentsContext.class,0);
		}
		public List<TypeRankSuffixContext> typeRankSuffix() {
			return getRuleContexts(TypeRankSuffixContext.class);
		}
		public TypeRankSuffixContext typeRankSuffix(int i) {
			return getRuleContext(TypeRankSuffixContext.class,i);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public List<TupleElementContext> tupleElement() {
			return getRuleContexts(TupleElementContext.class);
		}
		public TupleElementContext tupleElement(int i) {
			return getRuleContext(TupleElementContext.class,i);
		}
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_type; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitType(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeContext type() throws RecognitionException {
		TypeContext _localctx = new TypeContext(_ctx, getState());
		enterRule(_localctx, 52, RULE_type);
		int _la;
		try {
			setState(681);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ALIAS:
			case ASYNC:
			case BY:
			case DEFAULT:
			case FILE:
			case FROM:
			case GET:
			case GLOBAL:
			case GROUP:
			case INIT:
			case INTO:
			case JOIN:
			case LET:
			case NAMEOF:
			case NOTNULL:
			case ON:
			case ORDERBY:
			case PARTIAL:
			case RECORD:
			case REMOVE:
			case SCOPED:
			case SELECT:
			case SET:
			case UNMANAGED:
			case VALUE:
			case WHERE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case IDENTIFIER:
				enterOuterAlt(_localctx, 1);
				{
				setState(656);
				typeAtom();
				setState(658);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LT) {
					{
					setState(657);
					typeArguments();
					}
				}

				setState(663);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (((((_la - 109)) & ~0x3f) == 0 && ((1L << (_la - 109)) & 4195329L) != 0)) {
					{
					{
					setState(660);
					typeRankSuffix();
					}
					}
					setState(665);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 2);
				{
				setState(666);
				match(LPAREN);
				setState(667);
				tupleElement();
				setState(670); 
				_errHandler.sync(this);
				_la = _input.LA(1);
				do {
					{
					{
					setState(668);
					match(COMMA);
					setState(669);
					tupleElement();
					}
					}
					setState(672); 
					_errHandler.sync(this);
					_la = _input.LA(1);
				} while ( _la==COMMA );
				setState(674);
				match(RPAREN);
				setState(678);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (((((_la - 109)) & ~0x3f) == 0 && ((1L << (_la - 109)) & 4195329L) != 0)) {
					{
					{
					setState(675);
					typeRankSuffix();
					}
					}
					setState(680);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeAtomContext extends ParserRuleContext {
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public PrimitiveTypeKwdContext primitiveTypeKwd() {
			return getRuleContext(PrimitiveTypeKwdContext.class,0);
		}
		public TypeAtomContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeAtom; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeAtom(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeAtomContext typeAtom() throws RecognitionException {
		TypeAtomContext _localctx = new TypeAtomContext(_ctx, getState());
		enterRule(_localctx, 54, RULE_typeAtom);
		try {
			setState(685);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(683);
				qualifiedName();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(684);
				primitiveTypeKwd();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class PrimitiveTypeKwdContext extends ParserRuleContext {
		public TerminalNode BOOL() { return getToken(CSharpTestParser.BOOL, 0); }
		public TerminalNode BYTE() { return getToken(CSharpTestParser.BYTE, 0); }
		public TerminalNode SBYTE() { return getToken(CSharpTestParser.SBYTE, 0); }
		public TerminalNode CHAR_KW() { return getToken(CSharpTestParser.CHAR_KW, 0); }
		public TerminalNode DECIMAL() { return getToken(CSharpTestParser.DECIMAL, 0); }
		public TerminalNode DOUBLE_KW() { return getToken(CSharpTestParser.DOUBLE_KW, 0); }
		public TerminalNode FLOAT_KW() { return getToken(CSharpTestParser.FLOAT_KW, 0); }
		public TerminalNode INT() { return getToken(CSharpTestParser.INT, 0); }
		public TerminalNode LONG() { return getToken(CSharpTestParser.LONG, 0); }
		public TerminalNode OBJECT_KW() { return getToken(CSharpTestParser.OBJECT_KW, 0); }
		public TerminalNode SHORT() { return getToken(CSharpTestParser.SHORT, 0); }
		public TerminalNode STRING_KW() { return getToken(CSharpTestParser.STRING_KW, 0); }
		public TerminalNode UINT() { return getToken(CSharpTestParser.UINT, 0); }
		public TerminalNode ULONG() { return getToken(CSharpTestParser.ULONG, 0); }
		public TerminalNode USHORT() { return getToken(CSharpTestParser.USHORT, 0); }
		public TerminalNode DYNAMIC() { return getToken(CSharpTestParser.DYNAMIC, 0); }
		public TerminalNode VAR() { return getToken(CSharpTestParser.VAR, 0); }
		public PrimitiveTypeKwdContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_primitiveTypeKwd; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitPrimitiveTypeKwd(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrimitiveTypeKwdContext primitiveTypeKwd() throws RecognitionException {
		PrimitiveTypeKwdContext _localctx = new PrimitiveTypeKwdContext(_ctx, getState());
		enterRule(_localctx, 56, RULE_primitiveTypeKwd);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(687);
			_la = _input.LA(1);
			if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & 131071L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TupleElementContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode IDENTIFIER() { return getToken(CSharpTestParser.IDENTIFIER, 0); }
		public TupleElementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_tupleElement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTupleElement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TupleElementContext tupleElement() throws RecognitionException {
		TupleElementContext _localctx = new TupleElementContext(_ctx, getState());
		enterRule(_localctx, 58, RULE_tupleElement);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(689);
			type();
			setState(691);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==IDENTIFIER) {
				{
				setState(690);
				match(IDENTIFIER);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeRankSuffixContext extends ParserRuleContext {
		public TerminalNode QUESTION() { return getToken(CSharpTestParser.QUESTION, 0); }
		public TerminalNode STAR() { return getToken(CSharpTestParser.STAR, 0); }
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeRankSuffixContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeRankSuffix; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeRankSuffix(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeRankSuffixContext typeRankSuffix() throws RecognitionException {
		TypeRankSuffixContext _localctx = new TypeRankSuffixContext(_ctx, getState());
		enterRule(_localctx, 60, RULE_typeRankSuffix);
		int _la;
		try {
			setState(703);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case QUESTION:
				enterOuterAlt(_localctx, 1);
				{
				setState(693);
				match(QUESTION);
				}
				break;
			case STAR:
				enterOuterAlt(_localctx, 2);
				{
				setState(694);
				match(STAR);
				}
				break;
			case LBRACKET:
				enterOuterAlt(_localctx, 3);
				{
				setState(695);
				match(LBRACKET);
				setState(699);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==COMMA) {
					{
					{
					setState(696);
					match(COMMA);
					}
					}
					setState(701);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(702);
				match(RBRACKET);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeArgumentsContext extends ParserRuleContext {
		public TerminalNode LT() { return getToken(CSharpTestParser.LT, 0); }
		public List<TypeArgumentContext> typeArgument() {
			return getRuleContexts(TypeArgumentContext.class);
		}
		public TypeArgumentContext typeArgument(int i) {
			return getRuleContext(TypeArgumentContext.class,i);
		}
		public TerminalNode GT() { return getToken(CSharpTestParser.GT, 0); }
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeArguments; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeArguments(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeArgumentsContext typeArguments() throws RecognitionException {
		TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
		enterRule(_localctx, 62, RULE_typeArguments);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(705);
			match(LT);
			setState(706);
			typeArgument();
			setState(711);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(707);
				match(COMMA);
				setState(708);
				typeArgument();
				}
				}
				setState(713);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(714);
			match(GT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeArgumentContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode QUESTION() { return getToken(CSharpTestParser.QUESTION, 0); }
		public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeArgument; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeArgument(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeArgumentContext typeArgument() throws RecognitionException {
		TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
		enterRule(_localctx, 64, RULE_typeArgument);
		try {
			setState(718);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case ALIAS:
			case ASYNC:
			case BY:
			case DEFAULT:
			case FILE:
			case FROM:
			case GET:
			case GLOBAL:
			case GROUP:
			case INIT:
			case INTO:
			case JOIN:
			case LET:
			case NAMEOF:
			case NOTNULL:
			case ON:
			case ORDERBY:
			case PARTIAL:
			case RECORD:
			case REMOVE:
			case SCOPED:
			case SELECT:
			case SET:
			case UNMANAGED:
			case VALUE:
			case WHERE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case LPAREN:
			case IDENTIFIER:
				enterOuterAlt(_localctx, 1);
				{
				setState(716);
				type();
				}
				break;
			case QUESTION:
				enterOuterAlt(_localctx, 2);
				{
				setState(717);
				match(QUESTION);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeParameterListContext extends ParserRuleContext {
		public TerminalNode LT() { return getToken(CSharpTestParser.LT, 0); }
		public List<TypeParameterContext> typeParameter() {
			return getRuleContexts(TypeParameterContext.class);
		}
		public TypeParameterContext typeParameter(int i) {
			return getRuleContext(TypeParameterContext.class,i);
		}
		public TerminalNode GT() { return getToken(CSharpTestParser.GT, 0); }
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeParameterList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeParameterList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeParameterListContext typeParameterList() throws RecognitionException {
		TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
		enterRule(_localctx, 66, RULE_typeParameterList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(720);
			match(LT);
			setState(721);
			typeParameter();
			setState(726);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(722);
				match(COMMA);
				setState(723);
				typeParameter();
				}
				}
				setState(728);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(729);
			match(GT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeParameterContext extends ParserRuleContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public TerminalNode IN() { return getToken(CSharpTestParser.IN, 0); }
		public TerminalNode OUT() { return getToken(CSharpTestParser.OUT, 0); }
		public TypeParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeParameter; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeParameter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeParameterContext typeParameter() throws RecognitionException {
		TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
		enterRule(_localctx, 68, RULE_typeParameter);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(734);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(731);
				attributeSection();
				}
				}
				setState(736);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(738);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==IN || _la==OUT) {
				{
				setState(737);
				_la = _input.LA(1);
				if ( !(_la==IN || _la==OUT) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(740);
			identifier();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeListContext extends ParserRuleContext {
		public List<TypeContext> type() {
			return getRuleContexts(TypeContext.class);
		}
		public TypeContext type(int i) {
			return getRuleContext(TypeContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeListContext typeList() throws RecognitionException {
		TypeListContext _localctx = new TypeListContext(_ctx, getState());
		enterRule(_localctx, 70, RULE_typeList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(742);
			type();
			setState(747);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(743);
				match(COMMA);
				setState(744);
				type();
				}
				}
				setState(749);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeBaseListContext extends ParserRuleContext {
		public List<TypeBaseContext> typeBase() {
			return getRuleContexts(TypeBaseContext.class);
		}
		public TypeBaseContext typeBase(int i) {
			return getRuleContext(TypeBaseContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeBaseListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeBaseList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeBaseList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeBaseListContext typeBaseList() throws RecognitionException {
		TypeBaseListContext _localctx = new TypeBaseListContext(_ctx, getState());
		enterRule(_localctx, 72, RULE_typeBaseList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(750);
			typeBase();
			setState(755);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(751);
				match(COMMA);
				setState(752);
				typeBase();
				}
				}
				setState(757);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeBaseContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public TypeBaseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeBase; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeBase(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeBaseContext typeBase() throws RecognitionException {
		TypeBaseContext _localctx = new TypeBaseContext(_ctx, getState());
		enterRule(_localctx, 74, RULE_typeBase);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(758);
			type();
			setState(767);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LPAREN) {
				{
				setState(759);
				match(LPAREN);
				setState(763);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(760);
					balancedContent();
					}
					}
					setState(765);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(766);
				match(RPAREN);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeConstraintClauseContext extends ParserRuleContext {
		public TerminalNode WHERE() { return getToken(CSharpTestParser.WHERE, 0); }
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public TypeConstraintListContext typeConstraintList() {
			return getRuleContext(TypeConstraintListContext.class,0);
		}
		public TypeConstraintClauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeConstraintClause; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeConstraintClause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeConstraintClauseContext typeConstraintClause() throws RecognitionException {
		TypeConstraintClauseContext _localctx = new TypeConstraintClauseContext(_ctx, getState());
		enterRule(_localctx, 76, RULE_typeConstraintClause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(769);
			match(WHERE);
			setState(770);
			identifier();
			setState(771);
			match(COLON);
			setState(772);
			typeConstraintList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeConstraintListContext extends ParserRuleContext {
		public List<TypeConstraintContext> typeConstraint() {
			return getRuleContexts(TypeConstraintContext.class);
		}
		public TypeConstraintContext typeConstraint(int i) {
			return getRuleContext(TypeConstraintContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public TypeConstraintListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeConstraintList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeConstraintList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeConstraintListContext typeConstraintList() throws RecognitionException {
		TypeConstraintListContext _localctx = new TypeConstraintListContext(_ctx, getState());
		enterRule(_localctx, 78, RULE_typeConstraintList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(774);
			typeConstraint();
			setState(779);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(775);
				match(COMMA);
				setState(776);
				typeConstraint();
				}
				}
				setState(781);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class TypeConstraintContext extends ParserRuleContext {
		public TerminalNode NEW() { return getToken(CSharpTestParser.NEW, 0); }
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode CLASS() { return getToken(CSharpTestParser.CLASS, 0); }
		public TerminalNode QUESTION() { return getToken(CSharpTestParser.QUESTION, 0); }
		public TerminalNode STRUCT() { return getToken(CSharpTestParser.STRUCT, 0); }
		public TerminalNode NOTNULL() { return getToken(CSharpTestParser.NOTNULL, 0); }
		public TerminalNode UNMANAGED() { return getToken(CSharpTestParser.UNMANAGED, 0); }
		public TerminalNode DEFAULT() { return getToken(CSharpTestParser.DEFAULT, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TypeConstraintContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_typeConstraint; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitTypeConstraint(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TypeConstraintContext typeConstraint() throws RecognitionException {
		TypeConstraintContext _localctx = new TypeConstraintContext(_ctx, getState());
		enterRule(_localctx, 80, RULE_typeConstraint);
		int _la;
		try {
			setState(794);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(782);
				match(NEW);
				setState(783);
				match(LPAREN);
				setState(784);
				match(RPAREN);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(785);
				match(CLASS);
				setState(787);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==QUESTION) {
					{
					setState(786);
					match(QUESTION);
					}
				}

				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(789);
				match(STRUCT);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(790);
				match(NOTNULL);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(791);
				match(UNMANAGED);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(792);
				match(DEFAULT);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(793);
				type();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberNameContext extends ParserRuleContext {
		public List<IdentifierContext> identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public List<TerminalNode> DOT() { return getTokens(CSharpTestParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(CSharpTestParser.DOT, i);
		}
		public MemberNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_memberName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitMemberName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MemberNameContext memberName() throws RecognitionException {
		MemberNameContext _localctx = new MemberNameContext(_ctx, getState());
		enterRule(_localctx, 82, RULE_memberName);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(796);
			identifier();
			setState(801);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DOT) {
				{
				{
				setState(797);
				match(DOT);
				setState(798);
				identifier();
				}
				}
				setState(803);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class QualifiedNameContext extends ParserRuleContext {
		public List<IdentifierContext> identifier() {
			return getRuleContexts(IdentifierContext.class);
		}
		public IdentifierContext identifier(int i) {
			return getRuleContext(IdentifierContext.class,i);
		}
		public List<TerminalNode> DOT() { return getTokens(CSharpTestParser.DOT); }
		public TerminalNode DOT(int i) {
			return getToken(CSharpTestParser.DOT, i);
		}
		public List<TerminalNode> DOUBLE_COLON() { return getTokens(CSharpTestParser.DOUBLE_COLON); }
		public TerminalNode DOUBLE_COLON(int i) {
			return getToken(CSharpTestParser.DOUBLE_COLON, i);
		}
		public QualifiedNameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_qualifiedName; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitQualifiedName(this);
			else return visitor.visitChildren(this);
		}
	}

	public final QualifiedNameContext qualifiedName() throws RecognitionException {
		QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
		enterRule(_localctx, 84, RULE_qualifiedName);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(804);
			identifier();
			setState(809);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,103,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(805);
					_la = _input.LA(1);
					if ( !(_la==DOT || _la==DOUBLE_COLON) ) {
					_errHandler.recoverInline(this);
					}
					else {
						if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
						_errHandler.reportMatch(this);
						consume();
					}
					setState(806);
					identifier();
					}
					} 
				}
				setState(811);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,103,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class IdentifierContext extends ParserRuleContext {
		public TerminalNode IDENTIFIER() { return getToken(CSharpTestParser.IDENTIFIER, 0); }
		public TerminalNode ALIAS() { return getToken(CSharpTestParser.ALIAS, 0); }
		public TerminalNode ASYNC() { return getToken(CSharpTestParser.ASYNC, 0); }
		public TerminalNode BY() { return getToken(CSharpTestParser.BY, 0); }
		public TerminalNode DEFAULT() { return getToken(CSharpTestParser.DEFAULT, 0); }
		public TerminalNode DYNAMIC() { return getToken(CSharpTestParser.DYNAMIC, 0); }
		public TerminalNode FILE() { return getToken(CSharpTestParser.FILE, 0); }
		public TerminalNode FROM() { return getToken(CSharpTestParser.FROM, 0); }
		public TerminalNode GET() { return getToken(CSharpTestParser.GET, 0); }
		public TerminalNode GROUP() { return getToken(CSharpTestParser.GROUP, 0); }
		public TerminalNode GLOBAL() { return getToken(CSharpTestParser.GLOBAL, 0); }
		public TerminalNode INIT() { return getToken(CSharpTestParser.INIT, 0); }
		public TerminalNode INTO() { return getToken(CSharpTestParser.INTO, 0); }
		public TerminalNode JOIN() { return getToken(CSharpTestParser.JOIN, 0); }
		public TerminalNode LET() { return getToken(CSharpTestParser.LET, 0); }
		public TerminalNode NAMEOF() { return getToken(CSharpTestParser.NAMEOF, 0); }
		public TerminalNode NOTNULL() { return getToken(CSharpTestParser.NOTNULL, 0); }
		public TerminalNode ON() { return getToken(CSharpTestParser.ON, 0); }
		public TerminalNode ORDERBY() { return getToken(CSharpTestParser.ORDERBY, 0); }
		public TerminalNode PARTIAL() { return getToken(CSharpTestParser.PARTIAL, 0); }
		public TerminalNode RECORD() { return getToken(CSharpTestParser.RECORD, 0); }
		public TerminalNode REMOVE() { return getToken(CSharpTestParser.REMOVE, 0); }
		public TerminalNode SCOPED() { return getToken(CSharpTestParser.SCOPED, 0); }
		public TerminalNode SELECT() { return getToken(CSharpTestParser.SELECT, 0); }
		public TerminalNode SET() { return getToken(CSharpTestParser.SET, 0); }
		public TerminalNode UNMANAGED() { return getToken(CSharpTestParser.UNMANAGED, 0); }
		public TerminalNode VALUE() { return getToken(CSharpTestParser.VALUE, 0); }
		public TerminalNode VAR() { return getToken(CSharpTestParser.VAR, 0); }
		public TerminalNode WHERE() { return getToken(CSharpTestParser.WHERE, 0); }
		public TerminalNode WITH() { return getToken(CSharpTestParser.WITH, 0); }
		public TerminalNode YIELD() { return getToken(CSharpTestParser.YIELD, 0); }
		public IdentifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_identifier; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitIdentifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IdentifierContext identifier() throws RecognitionException {
		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
		enterRule(_localctx, 86, RULE_identifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(812);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4767707967724224804L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4400248815721L) != 0) || _la==IDENTIFIER) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class MemberBodyContext extends ParserRuleContext {
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode FATARROW() { return getToken(CSharpTestParser.FATARROW, 0); }
		public TerminalNode SEMI() { return getToken(CSharpTestParser.SEMI, 0); }
		public List<BodyContentContext> bodyContent() {
			return getRuleContexts(BodyContentContext.class);
		}
		public BodyContentContext bodyContent(int i) {
			return getRuleContext(BodyContentContext.class,i);
		}
		public MemberBodyContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_memberBody; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitMemberBody(this);
			else return visitor.visitChildren(this);
		}
	}

	public final MemberBodyContext memberBody() throws RecognitionException {
		MemberBodyContext _localctx = new MemberBodyContext(_ctx, getState());
		enterRule(_localctx, 88, RULE_memberBody);
		try {
			int _alt;
			setState(824);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(814);
				block();
				}
				break;
			case FATARROW:
				enterOuterAlt(_localctx, 2);
				{
				setState(815);
				match(FATARROW);
				setState(819);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,104,_ctx);
				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						setState(816);
						bodyContent();
						}
						} 
					}
					setState(821);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,104,_ctx);
				}
				setState(822);
				match(SEMI);
				}
				break;
			case SEMI:
				enterOuterAlt(_localctx, 3);
				{
				setState(823);
				match(SEMI);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BlockContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public List<BlockContentContext> blockContent() {
			return getRuleContexts(BlockContentContext.class);
		}
		public BlockContentContext blockContent(int i) {
			return getRuleContext(BlockContentContext.class,i);
		}
		public BlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitBlock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockContext block() throws RecognitionException {
		BlockContext _localctx = new BlockContext(_ctx, getState());
		enterRule(_localctx, 90, RULE_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(826);
			match(LBRACE);
			setState(830);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
				{
				{
				setState(827);
				blockContent();
				}
				}
				setState(832);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(833);
			match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BlockContentContext extends ParserRuleContext {
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public BlockContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blockContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitBlockContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockContentContext blockContent() throws RecognitionException {
		BlockContentContext _localctx = new BlockContentContext(_ctx, getState());
		enterRule(_localctx, 92, RULE_blockContent);
		int _la;
		try {
			setState(853);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(835);
				block();
				}
				break;
			case LBRACKET:
				enterOuterAlt(_localctx, 2);
				{
				setState(836);
				match(LBRACKET);
				setState(840);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(837);
					balancedContent();
					}
					}
					setState(842);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(843);
				match(RBRACKET);
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 3);
				{
				setState(844);
				match(LPAREN);
				setState(848);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(845);
					balancedContent();
					}
					}
					setState(850);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(851);
				match(RPAREN);
				}
				break;
			case ABSTRACT:
			case ALIAS:
			case AS:
			case ASSEMBLY:
			case ASYNC:
			case BASE:
			case BREAK:
			case BY:
			case CASE:
			case CATCH:
			case CHECKED:
			case CLASS:
			case CONST:
			case CONTINUE:
			case DEFAULT:
			case DELEGATE:
			case DO:
			case ELSE:
			case ENUM:
			case EVENT:
			case EXPLICIT:
			case EXTERN:
			case FALSE:
			case FILE:
			case FINALLY:
			case FIXED:
			case FOR:
			case FOREACH:
			case FROM:
			case GET:
			case GLOBAL:
			case GOTO:
			case GROUP:
			case IF:
			case IMPLICIT:
			case IN:
			case INIT:
			case INTERFACE:
			case INTERNAL:
			case INTO:
			case IS:
			case JOIN:
			case LET:
			case LOCK:
			case MODULE:
			case NAMEOF:
			case NAMESPACE:
			case NEW:
			case NOTNULL:
			case NULL:
			case ON:
			case OPERATOR:
			case ORDERBY:
			case OUT:
			case OVERRIDE:
			case PARAMS:
			case PARTIAL:
			case PRIVATE:
			case PROTECTED:
			case PUBLIC:
			case READONLY:
			case RECORD:
			case REF:
			case REMOVE:
			case REQUIRED:
			case RETURN:
			case SCOPED:
			case SEALED:
			case SELECT:
			case SET:
			case STATIC:
			case STRUCT:
			case SWITCH:
			case THIS:
			case THROW:
			case TRUE:
			case TRY:
			case TYPEOF:
			case UNMANAGED:
			case UNSAFE:
			case USING:
			case VALUE:
			case VIRTUAL:
			case VOID:
			case VOLATILE:
			case WHERE:
			case WHILE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case SEMI:
			case COMMA:
			case DOT:
			case FATARROW:
			case ARROW:
			case TILDE:
			case QUESTION:
			case COLON:
			case DOUBLE_COLON:
			case EQ:
			case EQEQ:
			case NEQ:
			case LT:
			case GT:
			case LTE:
			case GTE:
			case PLUS:
			case MINUS:
			case STAR:
			case DIV:
			case MOD:
			case AMP:
			case PIPE:
			case CARET:
			case BANG:
			case PLUSPLUS:
			case MINUSMINUS:
			case ANDAND:
			case OROR:
			case NULL_COND:
			case NULL_COAL:
			case NULL_COALEQ:
			case PLUSEQ:
			case MINUSEQ:
			case STAREQ:
			case DIVEQ:
			case MODEQ:
			case AMPEQ:
			case PIPEEQ:
			case CARETEQ:
			case AT_SIGN:
			case HASH:
			case STRING_LITERAL:
			case VERBATIM_STRING:
			case RAW_STRING:
			case INTERPOLATED_STRING:
			case CHAR_LITERAL:
			case INTEGER_LITERAL:
			case REAL_LITERAL:
			case BOM:
			case IDENTIFIER:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case PREPROCESSOR:
			case WS:
				enterOuterAlt(_localctx, 4);
				{
				setState(852);
				_la = _input.LA(1);
				if ( _la <= 0 || (((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & 63L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BodyContentContext extends ParserRuleContext {
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public BodyContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bodyContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitBodyContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BodyContentContext bodyContent() throws RecognitionException {
		BodyContentContext _localctx = new BodyContentContext(_ctx, getState());
		enterRule(_localctx, 94, RULE_bodyContent);
		int _la;
		try {
			setState(873);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(855);
				block();
				}
				break;
			case LBRACKET:
				enterOuterAlt(_localctx, 2);
				{
				setState(856);
				match(LBRACKET);
				setState(860);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(857);
					balancedContent();
					}
					}
					setState(862);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(863);
				match(RBRACKET);
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 3);
				{
				setState(864);
				match(LPAREN);
				setState(868);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(865);
					balancedContent();
					}
					}
					setState(870);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(871);
				match(RPAREN);
				}
				break;
			case ABSTRACT:
			case ALIAS:
			case AS:
			case ASSEMBLY:
			case ASYNC:
			case BASE:
			case BREAK:
			case BY:
			case CASE:
			case CATCH:
			case CHECKED:
			case CLASS:
			case CONST:
			case CONTINUE:
			case DEFAULT:
			case DELEGATE:
			case DO:
			case ELSE:
			case ENUM:
			case EVENT:
			case EXPLICIT:
			case EXTERN:
			case FALSE:
			case FILE:
			case FINALLY:
			case FIXED:
			case FOR:
			case FOREACH:
			case FROM:
			case GET:
			case GLOBAL:
			case GOTO:
			case GROUP:
			case IF:
			case IMPLICIT:
			case IN:
			case INIT:
			case INTERFACE:
			case INTERNAL:
			case INTO:
			case IS:
			case JOIN:
			case LET:
			case LOCK:
			case MODULE:
			case NAMEOF:
			case NAMESPACE:
			case NEW:
			case NOTNULL:
			case NULL:
			case ON:
			case OPERATOR:
			case ORDERBY:
			case OUT:
			case OVERRIDE:
			case PARAMS:
			case PARTIAL:
			case PRIVATE:
			case PROTECTED:
			case PUBLIC:
			case READONLY:
			case RECORD:
			case REF:
			case REMOVE:
			case REQUIRED:
			case RETURN:
			case SCOPED:
			case SEALED:
			case SELECT:
			case SET:
			case STATIC:
			case STRUCT:
			case SWITCH:
			case THIS:
			case THROW:
			case TRUE:
			case TRY:
			case TYPEOF:
			case UNMANAGED:
			case UNSAFE:
			case USING:
			case VALUE:
			case VIRTUAL:
			case VOID:
			case VOLATILE:
			case WHERE:
			case WHILE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case SEMI:
			case COMMA:
			case DOT:
			case FATARROW:
			case ARROW:
			case TILDE:
			case QUESTION:
			case COLON:
			case DOUBLE_COLON:
			case EQ:
			case EQEQ:
			case NEQ:
			case LT:
			case GT:
			case LTE:
			case GTE:
			case PLUS:
			case MINUS:
			case STAR:
			case DIV:
			case MOD:
			case AMP:
			case PIPE:
			case CARET:
			case BANG:
			case PLUSPLUS:
			case MINUSMINUS:
			case ANDAND:
			case OROR:
			case NULL_COND:
			case NULL_COAL:
			case NULL_COALEQ:
			case PLUSEQ:
			case MINUSEQ:
			case STAREQ:
			case DIVEQ:
			case MODEQ:
			case AMPEQ:
			case PIPEEQ:
			case CARETEQ:
			case AT_SIGN:
			case HASH:
			case STRING_LITERAL:
			case VERBATIM_STRING:
			case RAW_STRING:
			case INTERPOLATED_STRING:
			case CHAR_LITERAL:
			case INTEGER_LITERAL:
			case REAL_LITERAL:
			case BOM:
			case IDENTIFIER:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case PREPROCESSOR:
			case WS:
				enterOuterAlt(_localctx, 4);
				{
				setState(872);
				_la = _input.LA(1);
				if ( _la <= 0 || (((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & 63L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class BalancedContentContext extends ParserRuleContext {
		public TerminalNode LBRACE() { return getToken(CSharpTestParser.LBRACE, 0); }
		public TerminalNode RBRACE() { return getToken(CSharpTestParser.RBRACE, 0); }
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public BalancedContentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_balancedContent; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitBalancedContent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BalancedContentContext balancedContent() throws RecognitionException {
		BalancedContentContext _localctx = new BalancedContentContext(_ctx, getState());
		enterRule(_localctx, 96, RULE_balancedContent);
		int _la;
		try {
			setState(900);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case LBRACE:
				enterOuterAlt(_localctx, 1);
				{
				setState(875);
				match(LBRACE);
				setState(879);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(876);
					balancedContent();
					}
					}
					setState(881);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(882);
				match(RBRACE);
				}
				break;
			case LBRACKET:
				enterOuterAlt(_localctx, 2);
				{
				setState(883);
				match(LBRACKET);
				setState(887);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(884);
					balancedContent();
					}
					}
					setState(889);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(890);
				match(RBRACKET);
				}
				break;
			case LPAREN:
				enterOuterAlt(_localctx, 3);
				{
				setState(891);
				match(LPAREN);
				setState(895);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(892);
					balancedContent();
					}
					}
					setState(897);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(898);
				match(RPAREN);
				}
				break;
			case ABSTRACT:
			case ALIAS:
			case AS:
			case ASSEMBLY:
			case ASYNC:
			case BASE:
			case BREAK:
			case BY:
			case CASE:
			case CATCH:
			case CHECKED:
			case CLASS:
			case CONST:
			case CONTINUE:
			case DEFAULT:
			case DELEGATE:
			case DO:
			case ELSE:
			case ENUM:
			case EVENT:
			case EXPLICIT:
			case EXTERN:
			case FALSE:
			case FILE:
			case FINALLY:
			case FIXED:
			case FOR:
			case FOREACH:
			case FROM:
			case GET:
			case GLOBAL:
			case GOTO:
			case GROUP:
			case IF:
			case IMPLICIT:
			case IN:
			case INIT:
			case INTERFACE:
			case INTERNAL:
			case INTO:
			case IS:
			case JOIN:
			case LET:
			case LOCK:
			case MODULE:
			case NAMEOF:
			case NAMESPACE:
			case NEW:
			case NOTNULL:
			case NULL:
			case ON:
			case OPERATOR:
			case ORDERBY:
			case OUT:
			case OVERRIDE:
			case PARAMS:
			case PARTIAL:
			case PRIVATE:
			case PROTECTED:
			case PUBLIC:
			case READONLY:
			case RECORD:
			case REF:
			case REMOVE:
			case REQUIRED:
			case RETURN:
			case SCOPED:
			case SEALED:
			case SELECT:
			case SET:
			case STATIC:
			case STRUCT:
			case SWITCH:
			case THIS:
			case THROW:
			case TRUE:
			case TRY:
			case TYPEOF:
			case UNMANAGED:
			case UNSAFE:
			case USING:
			case VALUE:
			case VIRTUAL:
			case VOID:
			case VOLATILE:
			case WHERE:
			case WHILE:
			case WITH:
			case YIELD:
			case BOOL:
			case BYTE:
			case CHAR_KW:
			case DECIMAL:
			case DOUBLE_KW:
			case DYNAMIC:
			case FLOAT_KW:
			case INT:
			case LONG:
			case OBJECT_KW:
			case SBYTE:
			case SHORT:
			case STRING_KW:
			case UINT:
			case ULONG:
			case USHORT:
			case VAR:
			case SEMI:
			case COMMA:
			case DOT:
			case FATARROW:
			case ARROW:
			case TILDE:
			case QUESTION:
			case COLON:
			case DOUBLE_COLON:
			case EQ:
			case EQEQ:
			case NEQ:
			case LT:
			case GT:
			case LTE:
			case GTE:
			case PLUS:
			case MINUS:
			case STAR:
			case DIV:
			case MOD:
			case AMP:
			case PIPE:
			case CARET:
			case BANG:
			case PLUSPLUS:
			case MINUSMINUS:
			case ANDAND:
			case OROR:
			case NULL_COND:
			case NULL_COAL:
			case NULL_COALEQ:
			case PLUSEQ:
			case MINUSEQ:
			case STAREQ:
			case DIVEQ:
			case MODEQ:
			case AMPEQ:
			case PIPEEQ:
			case CARETEQ:
			case AT_SIGN:
			case HASH:
			case STRING_LITERAL:
			case VERBATIM_STRING:
			case RAW_STRING:
			case INTERPOLATED_STRING:
			case CHAR_LITERAL:
			case INTEGER_LITERAL:
			case REAL_LITERAL:
			case BOM:
			case IDENTIFIER:
			case LINE_COMMENT:
			case BLOCK_COMMENT:
			case PREPROCESSOR:
			case WS:
				enterOuterAlt(_localctx, 4);
				{
				setState(899);
				_la = _input.LA(1);
				if ( _la <= 0 || (((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & 63L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeSectionContext extends ParserRuleContext {
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public AttributeListContext attributeList() {
			return getRuleContext(AttributeListContext.class,0);
		}
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public AttributeTargetContext attributeTarget() {
			return getRuleContext(AttributeTargetContext.class,0);
		}
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public AttributeSectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeSection; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttributeSection(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeSectionContext attributeSection() throws RecognitionException {
		AttributeSectionContext _localctx = new AttributeSectionContext(_ctx, getState());
		enterRule(_localctx, 98, RULE_attributeSection);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(902);
			match(LBRACKET);
			setState(906);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
			case 1:
				{
				setState(903);
				attributeTarget();
				setState(904);
				match(COLON);
				}
				break;
			}
			setState(908);
			attributeList();
			setState(909);
			match(RBRACKET);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeTargetContext extends ParserRuleContext {
		public TerminalNode EVENT() { return getToken(CSharpTestParser.EVENT, 0); }
		public TerminalNode RETURN() { return getToken(CSharpTestParser.RETURN, 0); }
		public TerminalNode IDENTIFIER() { return getToken(CSharpTestParser.IDENTIFIER, 0); }
		public AttributeTargetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeTarget; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttributeTarget(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeTargetContext attributeTarget() throws RecognitionException {
		AttributeTargetContext _localctx = new AttributeTargetContext(_ctx, getState());
		enterRule(_localctx, 100, RULE_attributeTarget);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(911);
			_la = _input.LA(1);
			if ( !(_la==EVENT || _la==RETURN || _la==IDENTIFIER) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeListContext extends ParserRuleContext {
		public List<AttributeContext> attribute() {
			return getRuleContexts(AttributeContext.class);
		}
		public AttributeContext attribute(int i) {
			return getRuleContext(AttributeContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public AttributeListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttributeList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeListContext attributeList() throws RecognitionException {
		AttributeListContext _localctx = new AttributeListContext(_ctx, getState());
		enterRule(_localctx, 102, RULE_attributeList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(913);
			attribute();
			setState(918);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(914);
				match(COMMA);
				setState(915);
				attribute();
				}
				}
				setState(920);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeContext extends ParserRuleContext {
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public AttributeArgsContext attributeArgs() {
			return getRuleContext(AttributeArgsContext.class,0);
		}
		public AttributeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attribute; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttribute(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeContext attribute() throws RecognitionException {
		AttributeContext _localctx = new AttributeContext(_ctx, getState());
		enterRule(_localctx, 104, RULE_attribute);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(921);
			qualifiedName();
			setState(927);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==LPAREN) {
				{
				setState(922);
				match(LPAREN);
				setState(924);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4769115342616166692L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 145137737191529L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 12851347457L) != 0)) {
					{
					setState(923);
					attributeArgs();
					}
				}

				setState(926);
				match(RPAREN);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeArgsContext extends ParserRuleContext {
		public List<AttributeArgContext> attributeArg() {
			return getRuleContexts(AttributeArgContext.class);
		}
		public AttributeArgContext attributeArg(int i) {
			return getRuleContext(AttributeArgContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public AttributeArgsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeArgs; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttributeArgs(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeArgsContext attributeArgs() throws RecognitionException {
		AttributeArgsContext _localctx = new AttributeArgsContext(_ctx, getState());
		enterRule(_localctx, 106, RULE_attributeArgs);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(929);
			attributeArg();
			setState(934);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(930);
				match(COMMA);
				setState(931);
				attributeArg();
				}
				}
				setState(936);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeArgContext extends ParserRuleContext {
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode EQ() { return getToken(CSharpTestParser.EQ, 0); }
		public AttributeValueContext attributeValue() {
			return getRuleContext(AttributeValueContext.class,0);
		}
		public AttributeArgContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeArg; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttributeArg(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeArgContext attributeArg() throws RecognitionException {
		AttributeArgContext _localctx = new AttributeArgContext(_ctx, getState());
		enterRule(_localctx, 108, RULE_attributeArg);
		try {
			setState(942);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(937);
				identifier();
				setState(938);
				match(EQ);
				setState(939);
				attributeValue(0);
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(941);
				attributeValue(0);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class AttributeValueContext extends ParserRuleContext {
		public StringLiteralContext stringLiteral() {
			return getRuleContext(StringLiteralContext.class,0);
		}
		public TerminalNode CHAR_LITERAL() { return getToken(CSharpTestParser.CHAR_LITERAL, 0); }
		public TerminalNode TRUE() { return getToken(CSharpTestParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(CSharpTestParser.FALSE, 0); }
		public TerminalNode NULL() { return getToken(CSharpTestParser.NULL, 0); }
		public TerminalNode INTEGER_LITERAL() { return getToken(CSharpTestParser.INTEGER_LITERAL, 0); }
		public TerminalNode MINUS() { return getToken(CSharpTestParser.MINUS, 0); }
		public TerminalNode REAL_LITERAL() { return getToken(CSharpTestParser.REAL_LITERAL, 0); }
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public TerminalNode TYPEOF() { return getToken(CSharpTestParser.TYPEOF, 0); }
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TerminalNode NAMEOF() { return getToken(CSharpTestParser.NAMEOF, 0); }
		public TerminalNode NEW() { return getToken(CSharpTestParser.NEW, 0); }
		public TerminalNode LBRACKET() { return getToken(CSharpTestParser.LBRACKET, 0); }
		public TerminalNode RBRACKET() { return getToken(CSharpTestParser.RBRACKET, 0); }
		public AttributeArgsContext attributeArgs() {
			return getRuleContext(AttributeArgsContext.class,0);
		}
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public List<AttributeValueContext> attributeValue() {
			return getRuleContexts(AttributeValueContext.class);
		}
		public AttributeValueContext attributeValue(int i) {
			return getRuleContext(AttributeValueContext.class,i);
		}
		public TerminalNode PIPE() { return getToken(CSharpTestParser.PIPE, 0); }
		public TerminalNode PLUS() { return getToken(CSharpTestParser.PLUS, 0); }
		public AttributeValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_attributeValue; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitAttributeValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AttributeValueContext attributeValue() throws RecognitionException {
		return attributeValue(0);
	}

	private AttributeValueContext attributeValue(int _p) throws RecognitionException {
		ParserRuleContext _parentctx = _ctx;
		int _parentState = getState();
		AttributeValueContext _localctx = new AttributeValueContext(_ctx, _parentState);
		AttributeValueContext _prevctx = _localctx;
		int _startState = 110;
		enterRecursionRule(_localctx, 110, RULE_attributeValue, _p);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(989);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
			case 1:
				{
				setState(945);
				stringLiteral();
				}
				break;
			case 2:
				{
				setState(946);
				match(CHAR_LITERAL);
				}
				break;
			case 3:
				{
				setState(947);
				match(TRUE);
				}
				break;
			case 4:
				{
				setState(948);
				match(FALSE);
				}
				break;
			case 5:
				{
				setState(949);
				match(NULL);
				}
				break;
			case 6:
				{
				setState(951);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==MINUS) {
					{
					setState(950);
					match(MINUS);
					}
				}

				setState(953);
				match(INTEGER_LITERAL);
				}
				break;
			case 7:
				{
				setState(955);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==MINUS) {
					{
					setState(954);
					match(MINUS);
					}
				}

				setState(957);
				match(REAL_LITERAL);
				}
				break;
			case 8:
				{
				setState(958);
				qualifiedName();
				}
				break;
			case 9:
				{
				setState(959);
				match(TYPEOF);
				setState(960);
				match(LPAREN);
				setState(961);
				type();
				setState(962);
				match(RPAREN);
				}
				break;
			case 10:
				{
				setState(964);
				match(NAMEOF);
				setState(965);
				match(LPAREN);
				setState(966);
				qualifiedName();
				setState(967);
				match(RPAREN);
				}
				break;
			case 11:
				{
				setState(969);
				match(NEW);
				setState(970);
				qualifiedName();
				setState(973);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LBRACKET) {
					{
					setState(971);
					match(LBRACKET);
					setState(972);
					match(RBRACKET);
					}
				}

				setState(975);
				match(LPAREN);
				setState(977);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4769115342616166692L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 145137737191529L) != 0) || ((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & 12851347457L) != 0)) {
					{
					setState(976);
					attributeArgs();
					}
				}

				setState(979);
				match(RPAREN);
				}
				break;
			case 12:
				{
				setState(981);
				match(LPAREN);
				setState(985);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(982);
					balancedContent();
					}
					}
					setState(987);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(988);
				match(RPAREN);
				}
				break;
			}
			_ctx.stop = _input.LT(-1);
			setState(999);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( _parseListeners!=null ) triggerExitRuleEvent();
					_prevctx = _localctx;
					{
					setState(997);
					_errHandler.sync(this);
					switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
					case 1:
						{
						_localctx = new AttributeValueContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_attributeValue);
						setState(991);
						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
						setState(992);
						match(PIPE);
						setState(993);
						attributeValue(15);
						}
						break;
					case 2:
						{
						_localctx = new AttributeValueContext(_parentctx, _parentState);
						pushNewRecursionContext(_localctx, _startState, RULE_attributeValue);
						setState(994);
						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
						setState(995);
						match(PLUS);
						setState(996);
						attributeValue(14);
						}
						break;
					}
					} 
				}
				setState(1001);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class StringLiteralContext extends ParserRuleContext {
		public TerminalNode STRING_LITERAL() { return getToken(CSharpTestParser.STRING_LITERAL, 0); }
		public TerminalNode VERBATIM_STRING() { return getToken(CSharpTestParser.VERBATIM_STRING, 0); }
		public TerminalNode RAW_STRING() { return getToken(CSharpTestParser.RAW_STRING, 0); }
		public TerminalNode INTERPOLATED_STRING() { return getToken(CSharpTestParser.INTERPOLATED_STRING, 0); }
		public StringLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stringLiteral; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitStringLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StringLiteralContext stringLiteral() throws RecognitionException {
		StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState());
		enterRule(_localctx, 112, RULE_stringLiteral);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1002);
			_la = _input.LA(1);
			if ( !(((((_la - 155)) & ~0x3f) == 0 && ((1L << (_la - 155)) & 15L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterListContext extends ParserRuleContext {
		public List<ParameterContext> parameter() {
			return getRuleContexts(ParameterContext.class);
		}
		public ParameterContext parameter(int i) {
			return getRuleContext(ParameterContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public ParameterListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameterList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitParameterList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParameterListContext parameterList() throws RecognitionException {
		ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
		enterRule(_localctx, 114, RULE_parameterList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1004);
			parameter();
			setState(1009);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1005);
				match(COMMA);
				setState(1006);
				parameter();
				}
				}
				setState(1011);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterContext extends ParserRuleContext {
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public List<AttributeSectionContext> attributeSection() {
			return getRuleContexts(AttributeSectionContext.class);
		}
		public AttributeSectionContext attributeSection(int i) {
			return getRuleContext(AttributeSectionContext.class,i);
		}
		public List<ParameterModifierContext> parameterModifier() {
			return getRuleContexts(ParameterModifierContext.class);
		}
		public ParameterModifierContext parameterModifier(int i) {
			return getRuleContext(ParameterModifierContext.class,i);
		}
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode EQ() { return getToken(CSharpTestParser.EQ, 0); }
		public ParamDefaultContext paramDefault() {
			return getRuleContext(ParamDefaultContext.class,0);
		}
		public ParameterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameter; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitParameter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParameterContext parameter() throws RecognitionException {
		ParameterContext _localctx = new ParameterContext(_ctx, getState());
		enterRule(_localctx, 116, RULE_parameter);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(1015);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==LBRACKET) {
				{
				{
				setState(1012);
				attributeSection();
				}
				}
				setState(1017);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(1021);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					setState(1018);
					parameterModifier();
					}
					} 
				}
				setState(1023);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
			}
			setState(1024);
			type();
			setState(1026);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 4767707967724224804L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 4400248815721L) != 0) || _la==IDENTIFIER) {
				{
				setState(1025);
				identifier();
				}
			}

			setState(1030);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==EQ) {
				{
				setState(1028);
				match(EQ);
				setState(1029);
				paramDefault();
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParameterModifierContext extends ParserRuleContext {
		public TerminalNode REF() { return getToken(CSharpTestParser.REF, 0); }
		public TerminalNode OUT() { return getToken(CSharpTestParser.OUT, 0); }
		public TerminalNode IN() { return getToken(CSharpTestParser.IN, 0); }
		public TerminalNode PARAMS() { return getToken(CSharpTestParser.PARAMS, 0); }
		public TerminalNode THIS() { return getToken(CSharpTestParser.THIS, 0); }
		public TerminalNode READONLY() { return getToken(CSharpTestParser.READONLY, 0); }
		public TerminalNode SCOPED() { return getToken(CSharpTestParser.SCOPED, 0); }
		public ParameterModifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parameterModifier; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitParameterModifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParameterModifierContext parameterModifier() throws RecognitionException {
		ParameterModifierContext _localctx = new ParameterModifierContext(_ctx, getState());
		enterRule(_localctx, 118, RULE_parameterModifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1032);
			_la = _input.LA(1);
			if ( !(((((_la - 36)) & ~0x3f) == 0 && ((1L << (_la - 36)) & 277194473473L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ParamDefaultContext extends ParserRuleContext {
		public StringLiteralContext stringLiteral() {
			return getRuleContext(StringLiteralContext.class,0);
		}
		public TerminalNode CHAR_LITERAL() { return getToken(CSharpTestParser.CHAR_LITERAL, 0); }
		public TerminalNode TRUE() { return getToken(CSharpTestParser.TRUE, 0); }
		public TerminalNode FALSE() { return getToken(CSharpTestParser.FALSE, 0); }
		public TerminalNode NULL() { return getToken(CSharpTestParser.NULL, 0); }
		public TerminalNode INTEGER_LITERAL() { return getToken(CSharpTestParser.INTEGER_LITERAL, 0); }
		public TerminalNode MINUS() { return getToken(CSharpTestParser.MINUS, 0); }
		public TerminalNode REAL_LITERAL() { return getToken(CSharpTestParser.REAL_LITERAL, 0); }
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public TerminalNode NEW() { return getToken(CSharpTestParser.NEW, 0); }
		public TerminalNode LPAREN() { return getToken(CSharpTestParser.LPAREN, 0); }
		public TerminalNode RPAREN() { return getToken(CSharpTestParser.RPAREN, 0); }
		public TypeArgumentsContext typeArguments() {
			return getRuleContext(TypeArgumentsContext.class,0);
		}
		public List<BalancedContentContext> balancedContent() {
			return getRuleContexts(BalancedContentContext.class);
		}
		public BalancedContentContext balancedContent(int i) {
			return getRuleContext(BalancedContentContext.class,i);
		}
		public TerminalNode DEFAULT() { return getToken(CSharpTestParser.DEFAULT, 0); }
		public TypeContext type() {
			return getRuleContext(TypeContext.class,0);
		}
		public ParamDefaultContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramDefault; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitParamDefault(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamDefaultContext paramDefault() throws RecognitionException {
		ParamDefaultContext _localctx = new ParamDefaultContext(_ctx, getState());
		enterRule(_localctx, 120, RULE_paramDefault);
		int _la;
		try {
			setState(1077);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(1034);
				stringLiteral();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(1035);
				match(CHAR_LITERAL);
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(1036);
				match(TRUE);
				}
				break;
			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(1037);
				match(FALSE);
				}
				break;
			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(1038);
				match(NULL);
				}
				break;
			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(1040);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==MINUS) {
					{
					setState(1039);
					match(MINUS);
					}
				}

				setState(1042);
				match(INTEGER_LITERAL);
				}
				break;
			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(1044);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==MINUS) {
					{
					setState(1043);
					match(MINUS);
					}
				}

				setState(1046);
				match(REAL_LITERAL);
				}
				break;
			case 8:
				enterOuterAlt(_localctx, 8);
				{
				setState(1047);
				qualifiedName();
				}
				break;
			case 9:
				enterOuterAlt(_localctx, 9);
				{
				setState(1048);
				match(NEW);
				setState(1049);
				qualifiedName();
				setState(1051);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LT) {
					{
					setState(1050);
					typeArguments();
					}
				}

				setState(1053);
				match(LPAREN);
				setState(1057);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(1054);
					balancedContent();
					}
					}
					setState(1059);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1060);
				match(RPAREN);
				}
				break;
			case 10:
				enterOuterAlt(_localctx, 10);
				{
				setState(1062);
				match(DEFAULT);
				setState(1067);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==LPAREN) {
					{
					setState(1063);
					match(LPAREN);
					setState(1064);
					type();
					setState(1065);
					match(RPAREN);
					}
				}

				}
				break;
			case 11:
				enterOuterAlt(_localctx, 11);
				{
				setState(1069);
				match(LPAREN);
				setState(1073);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -2L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & -369435906932737L) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & 1099511627775L) != 0)) {
					{
					{
					setState(1070);
					balancedContent();
					}
					}
					setState(1075);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(1076);
				match(RPAREN);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArgumentListContext extends ParserRuleContext {
		public List<ArgumentContext> argument() {
			return getRuleContexts(ArgumentContext.class);
		}
		public ArgumentContext argument(int i) {
			return getRuleContext(ArgumentContext.class,i);
		}
		public List<TerminalNode> COMMA() { return getTokens(CSharpTestParser.COMMA); }
		public TerminalNode COMMA(int i) {
			return getToken(CSharpTestParser.COMMA, i);
		}
		public ArgumentListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_argumentList; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitArgumentList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArgumentListContext argumentList() throws RecognitionException {
		ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState());
		enterRule(_localctx, 122, RULE_argumentList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1079);
			argument();
			setState(1084);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(1080);
				match(COMMA);
				setState(1081);
				argument();
				}
				}
				setState(1086);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ArgumentContext extends ParserRuleContext {
		public QualifiedNameContext qualifiedName() {
			return getRuleContext(QualifiedNameContext.class,0);
		}
		public IdentifierContext identifier() {
			return getRuleContext(IdentifierContext.class,0);
		}
		public TerminalNode COLON() { return getToken(CSharpTestParser.COLON, 0); }
		public TerminalNode REF() { return getToken(CSharpTestParser.REF, 0); }
		public TerminalNode OUT() { return getToken(CSharpTestParser.OUT, 0); }
		public TerminalNode IN() { return getToken(CSharpTestParser.IN, 0); }
		public ArgumentContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_argument; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitArgument(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ArgumentContext argument() throws RecognitionException {
		ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
		enterRule(_localctx, 124, RULE_argument);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1090);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
			case 1:
				{
				setState(1087);
				identifier();
				setState(1088);
				match(COLON);
				}
				break;
			}
			setState(1093);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -9205357569625817088L) != 0)) {
				{
				setState(1092);
				_la = _input.LA(1);
				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & -9205357569625817088L) != 0)) ) {
				_errHandler.recoverInline(this);
				}
				else {
					if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
					_errHandler.reportMatch(this);
					consume();
				}
				}
			}

			setState(1095);
			qualifiedName();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	@SuppressWarnings("CheckReturnValue")
	public static class ModifierContext extends ParserRuleContext {
		public TerminalNode PUBLIC() { return getToken(CSharpTestParser.PUBLIC, 0); }
		public TerminalNode PRIVATE() { return getToken(CSharpTestParser.PRIVATE, 0); }
		public TerminalNode PROTECTED() { return getToken(CSharpTestParser.PROTECTED, 0); }
		public TerminalNode INTERNAL() { return getToken(CSharpTestParser.INTERNAL, 0); }
		public TerminalNode STATIC() { return getToken(CSharpTestParser.STATIC, 0); }
		public TerminalNode ABSTRACT() { return getToken(CSharpTestParser.ABSTRACT, 0); }
		public TerminalNode VIRTUAL() { return getToken(CSharpTestParser.VIRTUAL, 0); }
		public TerminalNode OVERRIDE() { return getToken(CSharpTestParser.OVERRIDE, 0); }
		public TerminalNode SEALED() { return getToken(CSharpTestParser.SEALED, 0); }
		public TerminalNode PARTIAL() { return getToken(CSharpTestParser.PARTIAL, 0); }
		public TerminalNode ASYNC() { return getToken(CSharpTestParser.ASYNC, 0); }
		public TerminalNode READONLY() { return getToken(CSharpTestParser.READONLY, 0); }
		public TerminalNode EXTERN() { return getToken(CSharpTestParser.EXTERN, 0); }
		public TerminalNode UNSAFE() { return getToken(CSharpTestParser.UNSAFE, 0); }
		public TerminalNode VOLATILE() { return getToken(CSharpTestParser.VOLATILE, 0); }
		public TerminalNode NEW() { return getToken(CSharpTestParser.NEW, 0); }
		public TerminalNode FIXED() { return getToken(CSharpTestParser.FIXED, 0); }
		public TerminalNode REQUIRED() { return getToken(CSharpTestParser.REQUIRED, 0); }
		public TerminalNode FILE() { return getToken(CSharpTestParser.FILE, 0); }
		public ModifierContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_modifier; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof CSharpTestVisitor ) return ((CSharpTestVisitor<? extends T>)visitor).visitModifier(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ModifierContext modifier() throws RecognitionException {
		ModifierContext _localctx = new ModifierContext(_ctx, getState());
		enterRule(_localctx, 126, RULE_modifier);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(1097);
			_la = _input.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 4503881652191100962L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1343561L) != 0)) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 55:
			return attributeValue_sempred((AttributeValueContext)_localctx, predIndex);
		}
		return true;
	}
	private boolean attributeValue_sempred(AttributeValueContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0:
			return precpred(_ctx, 14);
		case 1:
			return precpred(_ctx, 13);
		}
		return true;
	}

	public static final String _serializedATN =
		"\u0004\u0001\u00a7\u044c\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
		"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
		"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
		"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
		"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
		"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
		"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
		"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+
		"\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+
		"\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+
		"\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+
		"\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+
		"\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+
		",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+
		"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
		"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
		";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0001\u0000"+
		"\u0005\u0000\u0082\b\u0000\n\u0000\f\u0000\u0085\t\u0000\u0001\u0000\u0005"+
		"\u0000\u0088\b\u0000\n\u0000\f\u0000\u008b\t\u0000\u0001\u0000\u0005\u0000"+
		"\u008e\b\u0000\n\u0000\f\u0000\u0091\t\u0000\u0001\u0000\u0001\u0000\u0005"+
		"\u0000\u0095\b\u0000\n\u0000\f\u0000\u0098\t\u0000\u0003\u0000\u009a\b"+
		"\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
		"\u0001\u0001\u0001\u0001\u0002\u0003\u0002\u00a4\b\u0002\u0001\u0002\u0001"+
		"\u0002\u0003\u0002\u00a8\b\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0003"+
		"\u0002\u00ad\b\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001"+
		"\u0003\u0003\u0003\u00b4\b\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
		"\u0003\u0004\u0003\u00ba\b\u0003\u000b\u0003\f\u0003\u00bb\u0001\u0003"+
		"\u0001\u0003\u0003\u0003\u00c0\b\u0003\u0001\u0004\u0001\u0004\u0001\u0004"+
		"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005"+
		"\u0001\u0005\u0005\u0005\u00cc\b\u0005\n\u0005\f\u0005\u00cf\t\u0005\u0001"+
		"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u00d5\b\u0006\u0001"+
		"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u00db\b\u0007\n"+
		"\u0007\f\u0007\u00de\t\u0007\u0001\u0007\u0005\u0007\u00e1\b\u0007\n\u0007"+
		"\f\u0007\u00e4\t\u0007\u0001\u0007\u0001\u0007\u0001\b\u0005\b\u00e9\b"+
		"\b\n\b\f\b\u00ec\t\b\u0001\b\u0005\b\u00ef\b\b\n\b\f\b\u00f2\t\b\u0001"+
		"\b\u0001\b\u0001\b\u0003\b\u00f7\b\b\u0001\b\u0001\b\u0003\b\u00fb\b\b"+
		"\u0001\b\u0003\b\u00fe\b\b\u0001\b\u0001\b\u0003\b\u0102\b\b\u0001\b\u0005"+
		"\b\u0105\b\b\n\b\f\b\u0108\t\b\u0001\b\u0001\b\u0005\b\u010c\b\b\n\b\f"+
		"\b\u010f\t\b\u0001\b\u0001\b\u0003\b\u0113\b\b\u0001\t\u0001\t\u0001\t"+
		"\u0001\t\u0001\t\u0003\t\u011a\b\t\u0003\t\u011c\b\t\u0001\n\u0005\n\u011f"+
		"\b\n\n\n\f\n\u0122\t\n\u0001\n\u0005\n\u0125\b\n\n\n\f\n\u0128\t\n\u0001"+
		"\n\u0001\n\u0001\n\u0001\n\u0003\n\u012e\b\n\u0001\n\u0001\n\u0005\n\u0132"+
		"\b\n\n\n\f\n\u0135\t\n\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b"+
		"\u0005\u000b\u013c\b\u000b\n\u000b\f\u000b\u013f\t\u000b\u0001\u000b\u0003"+
		"\u000b\u0142\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+
		"\f\u0001\f\u0001\f\u0001\f\u0001\f\u0003\f\u014f\b\f\u0001\r\u0005\r\u0152"+
		"\b\r\n\r\f\r\u0155\t\r\u0001\r\u0005\r\u0158\b\r\n\r\f\r\u015b\t\r\u0001"+
		"\r\u0001\r\u0001\r\u0003\r\u0160\b\r\u0001\r\u0001\r\u0003\r\u0164\b\r"+
		"\u0001\r\u0001\r\u0005\r\u0168\b\r\n\r\f\r\u016b\t\r\u0001\r\u0001\r\u0001"+
		"\u000e\u0005\u000e\u0170\b\u000e\n\u000e\f\u000e\u0173\t\u000e\u0001\u000e"+
		"\u0005\u000e\u0176\b\u000e\n\u000e\f\u000e\u0179\t\u000e\u0001\u000e\u0001"+
		"\u000e\u0001\u000e\u0003\u000e\u017e\b\u000e\u0001\u000e\u0001\u000e\u0003"+
		"\u000e\u0182\b\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u0187"+
		"\b\u000e\n\u000e\f\u000e\u018a\t\u000e\u0001\u000e\u0003\u000e\u018d\b"+
		"\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u0193"+
		"\b\u000f\n\u000f\f\u000f\u0196\t\u000f\u0001\u000f\u0001\u000f\u0001\u0010"+
		"\u0005\u0010\u019b\b\u0010\n\u0010\f\u0010\u019e\t\u0010\u0001\u0010\u0005"+
		"\u0010\u01a1\b\u0010\n\u0010\f\u0010\u01a4\t\u0010\u0001\u0010\u0001\u0010"+
		"\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0005\u0011"+
		"\u01ad\b\u0011\n\u0011\f\u0011\u01b0\t\u0011\u0001\u0011\u0005\u0011\u01b3"+
		"\b\u0011\n\u0011\f\u0011\u01b6\t\u0011\u0001\u0011\u0003\u0011\u01b9\b"+
		"\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001"+
		"\u0012\u0005\u0012\u01c1\b\u0012\n\u0012\f\u0012\u01c4\t\u0012\u0001\u0012"+
		"\u0001\u0012\u0001\u0012\u0005\u0012\u01c9\b\u0012\n\u0012\f\u0012\u01cc"+
		"\t\u0012\u0001\u0012\u0003\u0012\u01cf\b\u0012\u0001\u0012\u0001\u0012"+
		"\u0005\u0012\u01d3\b\u0012\n\u0012\f\u0012\u01d6\t\u0012\u0001\u0012\u0001"+
		"\u0012\u0001\u0012\u0005\u0012\u01db\b\u0012\n\u0012\f\u0012\u01de\t\u0012"+
		"\u0003\u0012\u01e0\b\u0012\u0001\u0012\u0003\u0012\u01e3\b\u0012\u0001"+
		"\u0013\u0005\u0013\u01e6\b\u0013\n\u0013\f\u0013\u01e9\t\u0013\u0001\u0013"+
		"\u0005\u0013\u01ec\b\u0013\n\u0013\f\u0013\u01ef\t\u0013\u0001\u0013\u0001"+
		"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u01f6\b\u0013\u0001"+
		"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u01fc\b\u0013\n"+
		"\u0013\f\u0013\u01ff\t\u0013\u0001\u0013\u0003\u0013\u0202\b\u0013\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
		"\u0014\u0001\u0014\u0003\u0014\u021e\b\u0014\u0001\u0015\u0005\u0015\u0221"+
		"\b\u0015\n\u0015\f\u0015\u0224\t\u0015\u0001\u0015\u0005\u0015\u0227\b"+
		"\u0015\n\u0015\f\u0015\u022a\t\u0015\u0001\u0015\u0001\u0015\u0001\u0015"+
		"\u0001\u0015\u0001\u0015\u0003\u0015\u0231\b\u0015\u0001\u0015\u0001\u0015"+
		"\u0001\u0015\u0001\u0015\u0005\u0015\u0237\b\u0015\n\u0015\f\u0015\u023a"+
		"\t\u0015\u0001\u0015\u0003\u0015\u023d\b\u0015\u0001\u0016\u0005\u0016"+
		"\u0240\b\u0016\n\u0016\f\u0016\u0243\t\u0016\u0001\u0016\u0005\u0016\u0246"+
		"\b\u0016\n\u0016\f\u0016\u0249\t\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
		"\u0001\u0016\u0001\u0016\u0005\u0016\u0250\b\u0016\n\u0016\f\u0016\u0253"+
		"\t\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u0257\b\u0016\u0001\u0017"+
		"\u0005\u0017\u025a\b\u0017\n\u0017\f\u0017\u025d\t\u0017\u0001\u0017\u0005"+
		"\u0017\u0260\b\u0017\n\u0017\f\u0017\u0263\t\u0017\u0001\u0017\u0001\u0017"+
		"\u0001\u0017\u0001\u0017\u0003\u0017\u0269\b\u0017\u0001\u0017\u0001\u0017"+
		"\u0003\u0017\u026d\b\u0017\u0001\u0017\u0001\u0017\u0005\u0017\u0271\b"+
		"\u0017\n\u0017\f\u0017\u0274\t\u0017\u0001\u0017\u0001\u0017\u0001\u0018"+
		"\u0005\u0018\u0279\b\u0018\n\u0018\f\u0018\u027c\t\u0018\u0001\u0018\u0005"+
		"\u0018\u027f\b\u0018\n\u0018\f\u0018\u0282\t\u0018\u0001\u0018\u0001\u0018"+
		"\u0001\u0018\u0001\u0018\u0003\u0018\u0288\b\u0018\u0001\u0018\u0001\u0018"+
		"\u0001\u0018\u0001\u0019\u0001\u0019\u0003\u0019\u028f\b\u0019\u0001\u001a"+
		"\u0001\u001a\u0003\u001a\u0293\b\u001a\u0001\u001a\u0005\u001a\u0296\b"+
		"\u001a\n\u001a\f\u001a\u0299\t\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+
		"\u0001\u001a\u0004\u001a\u029f\b\u001a\u000b\u001a\f\u001a\u02a0\u0001"+
		"\u001a\u0001\u001a\u0005\u001a\u02a5\b\u001a\n\u001a\f\u001a\u02a8\t\u001a"+
		"\u0003\u001a\u02aa\b\u001a\u0001\u001b\u0001\u001b\u0003\u001b\u02ae\b"+
		"\u001b\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0003\u001d\u02b4"+
		"\b\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u02ba"+
		"\b\u001e\n\u001e\f\u001e\u02bd\t\u001e\u0001\u001e\u0003\u001e\u02c0\b"+
		"\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0005\u001f\u02c6"+
		"\b\u001f\n\u001f\f\u001f\u02c9\t\u001f\u0001\u001f\u0001\u001f\u0001 "+
		"\u0001 \u0003 \u02cf\b \u0001!\u0001!\u0001!\u0001!\u0005!\u02d5\b!\n"+
		"!\f!\u02d8\t!\u0001!\u0001!\u0001\"\u0005\"\u02dd\b\"\n\"\f\"\u02e0\t"+
		"\"\u0001\"\u0003\"\u02e3\b\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0005"+
		"#\u02ea\b#\n#\f#\u02ed\t#\u0001$\u0001$\u0001$\u0005$\u02f2\b$\n$\f$\u02f5"+
		"\t$\u0001%\u0001%\u0001%\u0005%\u02fa\b%\n%\f%\u02fd\t%\u0001%\u0003%"+
		"\u0300\b%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001\'\u0001\'\u0001\'\u0005"+
		"\'\u030a\b\'\n\'\f\'\u030d\t\'\u0001(\u0001(\u0001(\u0001(\u0001(\u0003"+
		"(\u0314\b(\u0001(\u0001(\u0001(\u0001(\u0001(\u0003(\u031b\b(\u0001)\u0001"+
		")\u0001)\u0005)\u0320\b)\n)\f)\u0323\t)\u0001*\u0001*\u0001*\u0005*\u0328"+
		"\b*\n*\f*\u032b\t*\u0001+\u0001+\u0001,\u0001,\u0001,\u0005,\u0332\b,"+
		"\n,\f,\u0335\t,\u0001,\u0001,\u0003,\u0339\b,\u0001-\u0001-\u0005-\u033d"+
		"\b-\n-\f-\u0340\t-\u0001-\u0001-\u0001.\u0001.\u0001.\u0005.\u0347\b."+
		"\n.\f.\u034a\t.\u0001.\u0001.\u0001.\u0005.\u034f\b.\n.\f.\u0352\t.\u0001"+
		".\u0001.\u0003.\u0356\b.\u0001/\u0001/\u0001/\u0005/\u035b\b/\n/\f/\u035e"+
		"\t/\u0001/\u0001/\u0001/\u0005/\u0363\b/\n/\f/\u0366\t/\u0001/\u0001/"+
		"\u0003/\u036a\b/\u00010\u00010\u00050\u036e\b0\n0\f0\u0371\t0\u00010\u0001"+
		"0\u00010\u00050\u0376\b0\n0\f0\u0379\t0\u00010\u00010\u00010\u00050\u037e"+
		"\b0\n0\f0\u0381\t0\u00010\u00010\u00030\u0385\b0\u00011\u00011\u00011"+
		"\u00011\u00031\u038b\b1\u00011\u00011\u00011\u00012\u00012\u00013\u0001"+
		"3\u00013\u00053\u0395\b3\n3\f3\u0398\t3\u00014\u00014\u00014\u00034\u039d"+
		"\b4\u00014\u00034\u03a0\b4\u00015\u00015\u00015\u00055\u03a5\b5\n5\f5"+
		"\u03a8\t5\u00016\u00016\u00016\u00016\u00016\u00036\u03af\b6\u00017\u0001"+
		"7\u00017\u00017\u00017\u00017\u00017\u00037\u03b8\b7\u00017\u00017\u0003"+
		"7\u03bc\b7\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+
		"7\u00017\u00017\u00017\u00017\u00017\u00017\u00017\u00037\u03ce\b7\u0001"+
		"7\u00017\u00037\u03d2\b7\u00017\u00017\u00017\u00017\u00057\u03d8\b7\n"+
		"7\f7\u03db\t7\u00017\u00037\u03de\b7\u00017\u00017\u00017\u00017\u0001"+
		"7\u00017\u00057\u03e6\b7\n7\f7\u03e9\t7\u00018\u00018\u00019\u00019\u0001"+
		"9\u00059\u03f0\b9\n9\f9\u03f3\t9\u0001:\u0005:\u03f6\b:\n:\f:\u03f9\t"+
		":\u0001:\u0005:\u03fc\b:\n:\f:\u03ff\t:\u0001:\u0001:\u0003:\u0403\b:"+
		"\u0001:\u0001:\u0003:\u0407\b:\u0001;\u0001;\u0001<\u0001<\u0001<\u0001"+
		"<\u0001<\u0001<\u0003<\u0411\b<\u0001<\u0001<\u0003<\u0415\b<\u0001<\u0001"+
		"<\u0001<\u0001<\u0001<\u0003<\u041c\b<\u0001<\u0001<\u0005<\u0420\b<\n"+
		"<\f<\u0423\t<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0003<"+
		"\u042c\b<\u0001<\u0001<\u0005<\u0430\b<\n<\f<\u0433\t<\u0001<\u0003<\u0436"+
		"\b<\u0001=\u0001=\u0001=\u0005=\u043b\b=\n=\f=\u043e\t=\u0001>\u0001>"+
		"\u0001>\u0003>\u0443\b>\u0001>\u0003>\u0446\b>\u0001>\u0001>\u0001?\u0001"+
		"?\u0001?\u0000\u0001n@\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012"+
		"\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\"+
		"^`bdfhjlnprtvxz|~\u0000\u000f\u0002\u0000\u0004\u0004--\u0002\u0000\f"+
		"\fHH\u0001\u0000kl\u0002\u0000\u0006\u0006JJ\u0002\u0000\u0015\u0015#"+
		"#\u0001\u0000Zj\u0002\u0000$$66\u0002\u0000ssyy\u001a\u0000\u0002\u0002"+
		"\u0005\u0005\b\b\u000f\u000f\u0018\u0018\u001d\u001f!!%%((*+..1133559"+
		"9>>@@CCEFOORRVVXY__jj\u00a3\u00a3\u0001\u0000kp\u0003\u0000\u0014\u0014"+
		"BB\u00a3\u00a3\u0001\u0000\u009b\u009e\u0007\u0000$$6688==??CCJJ\u0003"+
		"\u0000$$66??\u000f\u0000\u0001\u0001\u0005\u0005\u0016\u0016\u0018\u0018"+
		"\u001a\u001a\'\'00779=AADDGGPPSSUU\u04e0\u0000\u0083\u0001\u0000\u0000"+
		"\u0000\u0002\u009d\u0001\u0000\u0000\u0000\u0004\u00a3\u0001\u0000\u0000"+
		"\u0000\u0006\u00bf\u0001\u0000\u0000\u0000\b\u00c1\u0001\u0000\u0000\u0000"+
		"\n\u00c7\u0001\u0000\u0000\u0000\f\u00d4\u0001\u0000\u0000\u0000\u000e"+
		"\u00d6\u0001\u0000\u0000\u0000\u0010\u00ea\u0001\u0000\u0000\u0000\u0012"+
		"\u011b\u0001\u0000\u0000\u0000\u0014\u0120\u0001\u0000\u0000\u0000\u0016"+
		"\u0141\u0001\u0000\u0000\u0000\u0018\u014e\u0001\u0000\u0000\u0000\u001a"+
		"\u0153\u0001\u0000\u0000\u0000\u001c\u0171\u0001\u0000\u0000\u0000\u001e"+
		"\u018e\u0001\u0000\u0000\u0000 \u019c\u0001\u0000\u0000\u0000\"\u01ae"+
		"\u0001\u0000\u0000\u0000$\u01e2\u0001\u0000\u0000\u0000&\u01e7\u0001\u0000"+
		"\u0000\u0000(\u021d\u0001\u0000\u0000\u0000*\u0222\u0001\u0000\u0000\u0000"+
		",\u0241\u0001\u0000\u0000\u0000.\u025b\u0001\u0000\u0000\u00000\u027a"+
		"\u0001\u0000\u0000\u00002\u028e\u0001\u0000\u0000\u00004\u02a9\u0001\u0000"+
		"\u0000\u00006\u02ad\u0001\u0000\u0000\u00008\u02af\u0001\u0000\u0000\u0000"+
		":\u02b1\u0001\u0000\u0000\u0000<\u02bf\u0001\u0000\u0000\u0000>\u02c1"+
		"\u0001\u0000\u0000\u0000@\u02ce\u0001\u0000\u0000\u0000B\u02d0\u0001\u0000"+
		"\u0000\u0000D\u02de\u0001\u0000\u0000\u0000F\u02e6\u0001\u0000\u0000\u0000"+
		"H\u02ee\u0001\u0000\u0000\u0000J\u02f6\u0001\u0000\u0000\u0000L\u0301"+
		"\u0001\u0000\u0000\u0000N\u0306\u0001\u0000\u0000\u0000P\u031a\u0001\u0000"+
		"\u0000\u0000R\u031c\u0001\u0000\u0000\u0000T\u0324\u0001\u0000\u0000\u0000"+
		"V\u032c\u0001\u0000\u0000\u0000X\u0338\u0001\u0000\u0000\u0000Z\u033a"+
		"\u0001\u0000\u0000\u0000\\\u0355\u0001\u0000\u0000\u0000^\u0369\u0001"+
		"\u0000\u0000\u0000`\u0384\u0001\u0000\u0000\u0000b\u0386\u0001\u0000\u0000"+
		"\u0000d\u038f\u0001\u0000\u0000\u0000f\u0391\u0001\u0000\u0000\u0000h"+
		"\u0399\u0001\u0000\u0000\u0000j\u03a1\u0001\u0000\u0000\u0000l\u03ae\u0001"+
		"\u0000\u0000\u0000n\u03dd\u0001\u0000\u0000\u0000p\u03ea\u0001\u0000\u0000"+
		"\u0000r\u03ec\u0001\u0000\u0000\u0000t\u03f7\u0001\u0000\u0000\u0000v"+
		"\u0408\u0001\u0000\u0000\u0000x\u0435\u0001\u0000\u0000\u0000z\u0437\u0001"+
		"\u0000\u0000\u0000|\u0442\u0001\u0000\u0000\u0000~\u0449\u0001\u0000\u0000"+
		"\u0000\u0080\u0082\u0003\u0002\u0001\u0000\u0081\u0080\u0001\u0000\u0000"+
		"\u0000\u0082\u0085\u0001\u0000\u0000\u0000\u0083\u0081\u0001\u0000\u0000"+
		"\u0000\u0083\u0084\u0001\u0000\u0000\u0000\u0084\u0089\u0001\u0000\u0000"+
		"\u0000\u0085\u0083\u0001\u0000\u0000\u0000\u0086\u0088\u0003\u0004\u0002"+
		"\u0000\u0087\u0086\u0001\u0000\u0000\u0000\u0088\u008b\u0001\u0000\u0000"+
		"\u0000\u0089\u0087\u0001\u0000\u0000\u0000\u0089\u008a\u0001\u0000\u0000"+
		"\u0000\u008a\u008f\u0001\u0000\u0000\u0000\u008b\u0089\u0001\u0000\u0000"+
		"\u0000\u008c\u008e\u0003\b\u0004\u0000\u008d\u008c\u0001\u0000\u0000\u0000"+
		"\u008e\u0091\u0001\u0000\u0000\u0000\u008f\u008d\u0001\u0000\u0000\u0000"+
		"\u008f\u0090\u0001\u0000\u0000\u0000\u0090\u0099\u0001\u0000\u0000\u0000"+
		"\u0091\u008f\u0001\u0000\u0000\u0000\u0092\u009a\u0003\n\u0005\u0000\u0093"+
		"\u0095\u0003\f\u0006\u0000\u0094\u0093\u0001\u0000\u0000\u0000\u0095\u0098"+
		"\u0001\u0000\u0000\u0000\u0096\u0094\u0001\u0000\u0000\u0000\u0096\u0097"+
		"\u0001\u0000\u0000\u0000\u0097\u009a\u0001\u0000\u0000\u0000\u0098\u0096"+
		"\u0001\u0000\u0000\u0000\u0099\u0092\u0001\u0000\u0000\u0000\u0099\u0096"+
		"\u0001\u0000\u0000\u0000\u009a\u009b\u0001\u0000\u0000\u0000\u009b\u009c"+
		"\u0005\u0000\u0000\u0001\u009c\u0001\u0001\u0000\u0000\u0000\u009d\u009e"+
		"\u0005\u0016\u0000\u0000\u009e\u009f\u0005\u0002\u0000\u0000\u009f\u00a0"+
		"\u0003V+\u0000\u00a0\u00a1\u0005q\u0000\u0000\u00a1\u0003\u0001\u0000"+
		"\u0000\u0000\u00a2\u00a4\u0005\u001f\u0000\u0000\u00a3\u00a2\u0001\u0000"+
		"\u0000\u0000\u00a3\u00a4\u0001\u0000\u0000\u0000\u00a4\u00a5\u0001\u0000"+
		"\u0000\u0000\u00a5\u00a7\u0005Q\u0000\u0000\u00a6\u00a8\u0005G\u0000\u0000"+
		"\u00a7\u00a6\u0001\u0000\u0000\u0000\u00a7\u00a8\u0001\u0000\u0000\u0000"+
		"\u00a8\u00ac\u0001\u0000\u0000\u0000\u00a9\u00aa\u0003V+\u0000\u00aa\u00ab"+
		"\u0005z\u0000\u0000\u00ab\u00ad\u0001\u0000\u0000\u0000\u00ac\u00a9\u0001"+
		"\u0000\u0000\u0000\u00ac\u00ad\u0001\u0000\u0000\u0000\u00ad\u00ae\u0001"+
		"\u0000\u0000\u0000\u00ae\u00af\u0003\u0006\u0003\u0000\u00af\u00b0\u0005"+
		"q\u0000\u0000\u00b0\u0005\u0001\u0000\u0000\u0000\u00b1\u00b3\u0003T*"+
		"\u0000\u00b2\u00b4\u0003>\u001f\u0000\u00b3\u00b2\u0001\u0000\u0000\u0000"+
		"\u00b3\u00b4\u0001\u0000\u0000\u0000\u00b4\u00c0\u0001\u0000\u0000\u0000"+
		"\u00b5\u00b6\u0005o\u0000\u0000\u00b6\u00b9\u0003:\u001d\u0000\u00b7\u00b8"+
		"\u0005r\u0000\u0000\u00b8\u00ba\u0003:\u001d\u0000\u00b9\u00b7\u0001\u0000"+
		"\u0000\u0000\u00ba\u00bb\u0001\u0000\u0000\u0000\u00bb\u00b9\u0001\u0000"+
		"\u0000\u0000\u00bb\u00bc\u0001\u0000\u0000\u0000\u00bc\u00bd\u0001\u0000"+
		"\u0000\u0000\u00bd\u00be\u0005p\u0000\u0000\u00be\u00c0\u0001\u0000\u0000"+
		"\u0000\u00bf\u00b1\u0001\u0000\u0000\u0000\u00bf\u00b5\u0001\u0000\u0000"+
		"\u0000\u00c0\u0007\u0001\u0000\u0000\u0000\u00c1\u00c2\u0005m\u0000\u0000"+
		"\u00c2\u00c3\u0007\u0000\u0000\u0000\u00c3\u00c4\u0005x\u0000\u0000\u00c4"+
		"\u00c5\u0003f3\u0000\u00c5\u00c6\u0005n\u0000\u0000\u00c6\t\u0001\u0000"+
		"\u0000\u0000\u00c7\u00c8\u0005/\u0000\u0000\u00c8\u00c9\u0003T*\u0000"+
		"\u00c9\u00cd\u0005q\u0000\u0000\u00ca\u00cc\u0003\f\u0006\u0000\u00cb"+
		"\u00ca\u0001\u0000\u0000\u0000\u00cc\u00cf\u0001\u0000\u0000\u0000\u00cd"+
		"\u00cb\u0001\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000\u0000\u0000\u00ce"+
		"\u000b\u0001\u0000\u0000\u0000\u00cf\u00cd\u0001\u0000\u0000\u0000\u00d0"+
		"\u00d5\u0003\u000e\u0007\u0000\u00d1\u00d5\u0003\u0010\b\u0000\u00d2\u00d5"+
		"\u0003\u0014\n\u0000\u00d3\u00d5\u0003.\u0017\u0000\u00d4\u00d0\u0001"+
		"\u0000\u0000\u0000\u00d4\u00d1\u0001\u0000\u0000\u0000\u00d4\u00d2\u0001"+
		"\u0000\u0000\u0000\u00d4\u00d3\u0001\u0000\u0000\u0000\u00d5\r\u0001\u0000"+
		"\u0000\u0000\u00d6\u00d7\u0005/\u0000\u0000\u00d7\u00d8\u0003T*\u0000"+
		"\u00d8\u00dc\u0005k\u0000\u0000\u00d9\u00db\u0003\u0004\u0002\u0000\u00da"+
		"\u00d9\u0001\u0000\u0000\u0000\u00db\u00de\u0001\u0000\u0000\u0000\u00dc"+
		"\u00da\u0001\u0000\u0000\u0000\u00dc\u00dd\u0001\u0000\u0000\u0000\u00dd"+
		"\u00e2\u0001\u0000\u0000\u0000\u00de\u00dc\u0001\u0000\u0000\u0000\u00df"+
		"\u00e1\u0003\f\u0006\u0000\u00e0\u00df\u0001\u0000\u0000\u0000\u00e1\u00e4"+
		"\u0001\u0000\u0000\u0000\u00e2\u00e0\u0001\u0000\u0000\u0000\u00e2\u00e3"+
		"\u0001\u0000\u0000\u0000\u00e3\u00e5\u0001\u0000\u0000\u0000\u00e4\u00e2"+
		"\u0001\u0000\u0000\u0000\u00e5\u00e6\u0005l\u0000\u0000\u00e6\u000f\u0001"+
		"\u0000\u0000\u0000\u00e7\u00e9\u0003b1\u0000\u00e8\u00e7\u0001\u0000\u0000"+
		"\u0000\u00e9\u00ec\u0001\u0000\u0000\u0000\u00ea\u00e8\u0001\u0000\u0000"+
		"\u0000\u00ea\u00eb\u0001\u0000\u0000\u0000\u00eb\u00f0\u0001\u0000\u0000"+
		"\u0000\u00ec\u00ea\u0001\u0000\u0000\u0000\u00ed\u00ef\u0003~?\u0000\u00ee"+
		"\u00ed\u0001\u0000\u0000\u0000\u00ef\u00f2\u0001\u0000\u0000\u0000\u00f0"+
		"\u00ee\u0001\u0000\u0000\u0000\u00f0\u00f1\u0001\u0000\u0000\u0000\u00f1"+
		"\u00f3\u0001\u0000\u0000\u0000\u00f2\u00f0\u0001\u0000\u0000\u0000\u00f3"+
		"\u00f4\u0003\u0012\t\u0000\u00f4\u00f6\u0003V+\u0000\u00f5\u00f7\u0003"+
		"B!\u0000\u00f6\u00f5\u0001\u0000\u0000\u0000\u00f6\u00f7\u0001\u0000\u0000"+
		"\u0000\u00f7\u00fd\u0001\u0000\u0000\u0000\u00f8\u00fa\u0005o\u0000\u0000"+
		"\u00f9\u00fb\u0003r9\u0000\u00fa\u00f9\u0001\u0000\u0000\u0000\u00fa\u00fb"+
		"\u0001\u0000\u0000\u0000\u00fb\u00fc\u0001\u0000\u0000\u0000\u00fc\u00fe"+
		"\u0005p\u0000\u0000\u00fd\u00f8\u0001\u0000\u0000\u0000\u00fd\u00fe\u0001"+
		"\u0000\u0000\u0000\u00fe\u0101\u0001\u0000\u0000\u0000\u00ff\u0100\u0005"+
		"x\u0000\u0000\u0100\u0102\u0003H$\u0000\u0101\u00ff\u0001\u0000\u0000"+
		"\u0000\u0101\u0102\u0001\u0000\u0000\u0000\u0102\u0106\u0001\u0000\u0000"+
		"\u0000\u0103\u0105\u0003L&\u0000\u0104\u0103\u0001\u0000\u0000\u0000\u0105"+
		"\u0108\u0001\u0000\u0000\u0000\u0106\u0104\u0001\u0000\u0000\u0000\u0106"+
		"\u0107\u0001\u0000\u0000\u0000\u0107\u0112\u0001\u0000\u0000\u0000\u0108"+
		"\u0106\u0001\u0000\u0000\u0000\u0109\u010d\u0005k\u0000\u0000\u010a\u010c"+
		"\u0003\u0018\f\u0000\u010b\u010a\u0001\u0000\u0000\u0000\u010c\u010f\u0001"+
		"\u0000\u0000\u0000\u010d\u010b\u0001\u0000\u0000\u0000\u010d\u010e\u0001"+
		"\u0000\u0000\u0000\u010e\u0110\u0001\u0000\u0000\u0000\u010f\u010d\u0001"+
		"\u0000\u0000\u0000\u0110\u0113\u0005l\u0000\u0000\u0111\u0113\u0005q\u0000"+
		"\u0000\u0112\u0109\u0001\u0000\u0000\u0000\u0112\u0111\u0001\u0000\u0000"+
		"\u0000\u0113\u0011\u0001\u0000\u0000\u0000\u0114\u011c\u0005\f\u0000\u0000"+
		"\u0115\u011c\u0005&\u0000\u0000\u0116\u011c\u0005H\u0000\u0000\u0117\u0119"+
		"\u0005>\u0000\u0000\u0118\u011a\u0007\u0001\u0000\u0000\u0119\u0118\u0001"+
		"\u0000\u0000\u0000\u0119\u011a\u0001\u0000\u0000\u0000\u011a\u011c\u0001"+
		"\u0000\u0000\u0000\u011b\u0114\u0001\u0000\u0000\u0000\u011b\u0115\u0001"+
		"\u0000\u0000\u0000\u011b\u0116\u0001\u0000\u0000\u0000\u011b\u0117\u0001"+
		"\u0000\u0000\u0000\u011c\u0013\u0001\u0000\u0000\u0000\u011d\u011f\u0003"+
		"b1\u0000\u011e\u011d\u0001\u0000\u0000\u0000\u011f\u0122\u0001\u0000\u0000"+
		"\u0000\u0120\u011e\u0001\u0000\u0000\u0000\u0120\u0121\u0001\u0000\u0000"+
		"\u0000\u0121\u0126\u0001\u0000\u0000\u0000\u0122\u0120\u0001\u0000\u0000"+
		"\u0000\u0123\u0125\u0003~?\u0000\u0124\u0123\u0001\u0000\u0000\u0000\u0125"+
		"\u0128\u0001\u0000\u0000\u0000\u0126\u0124\u0001\u0000\u0000\u0000\u0126"+
		"\u0127\u0001\u0000\u0000\u0000\u0127\u0129\u0001\u0000\u0000\u0000\u0128"+
		"\u0126\u0001\u0000\u0000\u0000\u0129\u012a\u0005\u0013\u0000\u0000\u012a"+
		"\u012d\u0003V+\u0000\u012b\u012c\u0005x\u0000\u0000\u012c\u012e\u0003"+
		"4\u001a\u0000\u012d\u012b\u0001\u0000\u0000\u0000\u012d\u012e\u0001\u0000"+
		"\u0000\u0000\u012e\u012f\u0001\u0000\u0000\u0000\u012f\u0133\u0005k\u0000"+
		"\u0000\u0130\u0132\u0003\u0016\u000b\u0000\u0131\u0130\u0001\u0000\u0000"+
		"\u0000\u0132\u0135\u0001\u0000\u0000\u0000\u0133\u0131\u0001\u0000\u0000"+
		"\u0000\u0133\u0134\u0001\u0000\u0000\u0000\u0134\u0136\u0001\u0000\u0000"+
		"\u0000\u0135\u0133\u0001\u0000\u0000\u0000\u0136\u0137\u0005l\u0000\u0000"+
		"\u0137\u0015\u0001\u0000\u0000\u0000\u0138\u0142\b\u0002\u0000\u0000\u0139"+
		"\u013d\u0005k\u0000\u0000\u013a\u013c\u0003\u0016\u000b\u0000\u013b\u013a"+
		"\u0001\u0000\u0000\u0000\u013c\u013f\u0001\u0000\u0000\u0000\u013d\u013b"+
		"\u0001\u0000\u0000\u0000\u013d\u013e\u0001\u0000\u0000\u0000\u013e\u0140"+
		"\u0001\u0000\u0000\u0000\u013f\u013d\u0001\u0000\u0000\u0000\u0140\u0142"+
		"\u0005l\u0000\u0000\u0141\u0138\u0001\u0000\u0000\u0000\u0141\u0139\u0001"+
		"\u0000\u0000\u0000\u0142\u0017\u0001\u0000\u0000\u0000\u0143\u014f\u0003"+
		"\u0010\b\u0000\u0144\u014f\u0003\u0014\n\u0000\u0145\u014f\u0003.\u0017"+
		"\u0000\u0146\u014f\u0003\u001a\r\u0000\u0147\u014f\u0003\u001c\u000e\u0000"+
		"\u0148\u014f\u0003 \u0010\u0000\u0149\u014f\u00030\u0018\u0000\u014a\u014f"+
		"\u0003\"\u0011\u0000\u014b\u014f\u0003&\u0013\u0000\u014c\u014f\u0003"+
		"*\u0015\u0000\u014d\u014f\u0003,\u0016\u0000\u014e\u0143\u0001\u0000\u0000"+
		"\u0000\u014e\u0144\u0001\u0000\u0000\u0000\u014e\u0145\u0001\u0000\u0000"+
		"\u0000\u014e\u0146\u0001\u0000\u0000\u0000\u014e\u0147\u0001\u0000\u0000"+
		"\u0000\u014e\u0148\u0001\u0000\u0000\u0000\u014e\u0149\u0001\u0000\u0000"+
		"\u0000\u014e\u014a\u0001\u0000\u0000\u0000\u014e\u014b\u0001\u0000\u0000"+
		"\u0000\u014e\u014c\u0001\u0000\u0000\u0000\u014e\u014d\u0001\u0000\u0000"+
		"\u0000\u014f\u0019\u0001\u0000\u0000\u0000\u0150\u0152\u0003b1\u0000\u0151"+
		"\u0150\u0001\u0000\u0000\u0000\u0152\u0155\u0001\u0000\u0000\u0000\u0153"+
		"\u0151\u0001\u0000\u0000\u0000\u0153\u0154\u0001\u0000\u0000\u0000\u0154"+
		"\u0159\u0001\u0000\u0000\u0000\u0155\u0153\u0001\u0000\u0000\u0000\u0156"+
		"\u0158\u0003~?\u0000\u0157\u0156\u0001\u0000\u0000\u0000\u0158\u015b\u0001"+
		"\u0000\u0000\u0000\u0159\u0157\u0001\u0000\u0000\u0000\u0159\u015a\u0001"+
		"\u0000\u0000\u0000\u015a\u015c\u0001\u0000\u0000\u0000\u015b\u0159\u0001"+
		"\u0000\u0000\u0000\u015c\u015d\u00032\u0019\u0000\u015d\u015f\u0003R)"+
		"\u0000\u015e\u0160\u0003B!\u0000\u015f\u015e\u0001\u0000\u0000\u0000\u015f"+
		"\u0160\u0001\u0000\u0000\u0000\u0160\u0161\u0001\u0000\u0000\u0000\u0161"+
		"\u0163\u0005o\u0000\u0000\u0162\u0164\u0003r9\u0000\u0163\u0162\u0001"+
		"\u0000\u0000\u0000\u0163\u0164\u0001\u0000\u0000\u0000\u0164\u0165\u0001"+
		"\u0000\u0000\u0000\u0165\u0169\u0005p\u0000\u0000\u0166\u0168\u0003L&"+
		"\u0000\u0167\u0166\u0001\u0000\u0000\u0000\u0168\u016b\u0001\u0000\u0000"+
		"\u0000\u0169\u0167\u0001\u0000\u0000\u0000\u0169\u016a\u0001\u0000\u0000"+
		"\u0000\u016a\u016c\u0001\u0000\u0000\u0000\u016b\u0169\u0001\u0000\u0000"+
		"\u0000\u016c\u016d\u0003X,\u0000\u016d\u001b\u0001\u0000\u0000\u0000\u016e"+
		"\u0170\u0003b1\u0000\u016f\u016e\u0001\u0000\u0000\u0000\u0170\u0173\u0001"+
		"\u0000\u0000\u0000\u0171\u016f\u0001\u0000\u0000\u0000\u0171\u0172\u0001"+
		"\u0000\u0000\u0000\u0172\u0177\u0001\u0000\u0000\u0000\u0173\u0171\u0001"+
		"\u0000\u0000\u0000\u0174\u0176\u0003~?\u0000\u0175\u0174\u0001\u0000\u0000"+
		"\u0000\u0176\u0179\u0001\u0000\u0000\u0000\u0177\u0175\u0001\u0000\u0000"+
		"\u0000\u0177\u0178\u0001\u0000\u0000\u0000\u0178\u017a\u0001\u0000\u0000"+
		"\u0000\u0179\u0177\u0001\u0000\u0000\u0000\u017a\u017b\u0003V+\u0000\u017b"+
		"\u017d\u0005o\u0000\u0000\u017c\u017e\u0003r9\u0000\u017d\u017c\u0001"+
		"\u0000\u0000\u0000\u017d\u017e\u0001\u0000\u0000\u0000\u017e\u017f\u0001"+
		"\u0000\u0000\u0000\u017f\u0181\u0005p\u0000\u0000\u0180\u0182\u0003\u001e"+
		"\u000f\u0000\u0181\u0180\u0001\u0000\u0000\u0000\u0181\u0182\u0001\u0000"+
		"\u0000\u0000\u0182\u018c\u0001\u0000\u0000\u0000\u0183\u018d\u0003Z-\u0000"+
		"\u0184\u0188\u0005t\u0000\u0000\u0185\u0187\u0003^/\u0000\u0186\u0185"+
		"\u0001\u0000\u0000\u0000\u0187\u018a\u0001\u0000\u0000\u0000\u0188\u0186"+
		"\u0001\u0000\u0000\u0000\u0188\u0189\u0001\u0000\u0000\u0000\u0189\u018b"+
		"\u0001\u0000\u0000\u0000\u018a\u0188\u0001\u0000\u0000\u0000\u018b\u018d"+
		"\u0005q\u0000\u0000\u018c\u0183\u0001\u0000\u0000\u0000\u018c\u0184\u0001"+
		"\u0000\u0000\u0000\u018d\u001d\u0001\u0000\u0000\u0000\u018e\u018f\u0005"+
		"x\u0000\u0000\u018f\u0190\u0007\u0003\u0000\u0000\u0190\u0194\u0005o\u0000"+
		"\u0000\u0191\u0193\u0003`0\u0000\u0192\u0191\u0001\u0000\u0000\u0000\u0193"+
		"\u0196\u0001\u0000\u0000\u0000\u0194\u0192\u0001\u0000\u0000\u0000\u0194"+
		"\u0195\u0001\u0000\u0000\u0000\u0195\u0197\u0001\u0000\u0000\u0000\u0196"+
		"\u0194\u0001\u0000\u0000\u0000\u0197\u0198\u0005p\u0000\u0000\u0198\u001f"+
		"\u0001\u0000\u0000\u0000\u0199\u019b\u0003b1\u0000\u019a\u0199\u0001\u0000"+
		"\u0000\u0000\u019b\u019e\u0001\u0000\u0000\u0000\u019c\u019a\u0001\u0000"+
		"\u0000\u0000\u019c\u019d\u0001\u0000\u0000\u0000\u019d\u01a2\u0001\u0000"+
		"\u0000\u0000\u019e\u019c\u0001\u0000\u0000\u0000\u019f\u01a1\u0003~?\u0000"+
		"\u01a0\u019f\u0001\u0000\u0000\u0000\u01a1\u01a4\u0001\u0000\u0000\u0000"+
		"\u01a2\u01a0\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001\u0000\u0000\u0000"+
		"\u01a3\u01a5\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001\u0000\u0000\u0000"+
		"\u01a5\u01a6\u0005v\u0000\u0000\u01a6\u01a7\u0003V+\u0000\u01a7\u01a8"+
		"\u0005o\u0000\u0000\u01a8\u01a9\u0005p\u0000\u0000\u01a9\u01aa\u0003Z"+
		"-\u0000\u01aa!\u0001\u0000\u0000\u0000\u01ab\u01ad\u0003b1\u0000\u01ac"+
		"\u01ab\u0001\u0000\u0000\u0000\u01ad\u01b0\u0001\u0000\u0000\u0000\u01ae"+
		"\u01ac\u0001\u0000\u0000\u0000\u01ae\u01af\u0001\u0000\u0000\u0000\u01af"+
		"\u01b4\u0001\u0000\u0000\u0000\u01b0\u01ae\u0001\u0000\u0000\u0000\u01b1"+
		"\u01b3\u0003~?\u0000\u01b2\u01b1\u0001\u0000\u0000\u0000\u01b3\u01b6\u0001"+
		"\u0000\u0000\u0000\u01b4\u01b2\u0001\u0000\u0000\u0000\u01b4\u01b5\u0001"+
		"\u0000\u0000\u0000\u01b5\u01b8\u0001\u0000\u0000\u0000\u01b6\u01b4\u0001"+
		"\u0000\u0000\u0000\u01b7\u01b9\u0005\r\u0000\u0000\u01b8\u01b7\u0001\u0000"+
		"\u0000\u0000\u01b8\u01b9\u0001\u0000\u0000\u0000\u01b9\u01ba\u0001\u0000"+
		"\u0000\u0000\u01ba\u01bb\u00034\u001a\u0000\u01bb\u01bc\u0003R)\u0000"+
		"\u01bc\u01bd\u0003$\u0012\u0000\u01bd#\u0001\u0000\u0000\u0000\u01be\u01c2"+
		"\u0005k\u0000\u0000\u01bf\u01c1\u0003^/\u0000\u01c0\u01bf\u0001\u0000"+
		"\u0000\u0000\u01c1\u01c4\u0001\u0000\u0000\u0000\u01c2\u01c0\u0001\u0000"+
		"\u0000\u0000\u01c2\u01c3\u0001\u0000\u0000\u0000\u01c3\u01c5\u0001\u0000"+
		"\u0000\u0000\u01c4\u01c2\u0001\u0000\u0000\u0000\u01c5\u01ce\u0005l\u0000"+
		"\u0000\u01c6\u01ca\u0005z\u0000\u0000\u01c7\u01c9\u0003^/\u0000\u01c8"+
		"\u01c7\u0001\u0000\u0000\u0000\u01c9\u01cc\u0001\u0000\u0000\u0000\u01ca"+
		"\u01c8\u0001\u0000\u0000\u0000\u01ca\u01cb\u0001\u0000\u0000\u0000\u01cb"+
		"\u01cd\u0001\u0000\u0000\u0000\u01cc\u01ca\u0001\u0000\u0000\u0000\u01cd"+
		"\u01cf\u0005q\u0000\u0000\u01ce\u01c6\u0001\u0000\u0000\u0000\u01ce\u01cf"+
		"\u0001\u0000\u0000\u0000\u01cf\u01e3\u0001\u0000\u0000\u0000\u01d0\u01d4"+
		"\u0005t\u0000\u0000\u01d1\u01d3\u0003^/\u0000\u01d2\u01d1\u0001\u0000"+
		"\u0000\u0000\u01d3\u01d6\u0001\u0000\u0000\u0000\u01d4\u01d2\u0001\u0000"+
		"\u0000\u0000\u01d4\u01d5\u0001\u0000\u0000\u0000\u01d5\u01d7\u0001\u0000"+
		"\u0000\u0000\u01d6\u01d4\u0001\u0000\u0000\u0000\u01d7\u01e3\u0005q\u0000"+
		"\u0000\u01d8\u01dc\u0005z\u0000\u0000\u01d9\u01db\u0003^/\u0000\u01da"+
		"\u01d9\u0001\u0000\u0000\u0000\u01db\u01de\u0001\u0000\u0000\u0000\u01dc"+
		"\u01da\u0001\u0000\u0000\u0000\u01dc\u01dd\u0001\u0000\u0000\u0000\u01dd"+
		"\u01e0\u0001\u0000\u0000\u0000\u01de\u01dc\u0001\u0000\u0000\u0000\u01df"+
		"\u01d8\u0001\u0000\u0000\u0000\u01df\u01e0\u0001\u0000\u0000\u0000\u01e0"+
		"\u01e1\u0001\u0000\u0000\u0000\u01e1\u01e3\u0005q\u0000\u0000\u01e2\u01be"+
		"\u0001\u0000\u0000\u0000\u01e2\u01d0\u0001\u0000\u0000\u0000\u01e2\u01df"+
		"\u0001\u0000\u0000\u0000\u01e3%\u0001\u0000\u0000\u0000\u01e4\u01e6\u0003"+
		"b1\u0000\u01e5\u01e4\u0001\u0000\u0000\u0000\u01e6\u01e9\u0001\u0000\u0000"+
		"\u0000\u01e7\u01e5\u0001\u0000\u0000\u0000\u01e7\u01e8\u0001\u0000\u0000"+
		"\u0000\u01e8\u01ed\u0001\u0000\u0000\u0000\u01e9\u01e7\u0001\u0000\u0000"+
		"\u0000\u01ea\u01ec\u0003~?\u0000\u01eb\u01ea\u0001\u0000\u0000\u0000\u01ec"+
		"\u01ef\u0001\u0000\u0000\u0000\u01ed\u01eb\u0001\u0000\u0000\u0000\u01ed"+
		"\u01ee\u0001\u0000\u0000\u0000\u01ee\u01f0\u0001\u0000\u0000\u0000\u01ef"+
		"\u01ed\u0001\u0000\u0000\u0000\u01f0\u01f1\u00034\u001a\u0000\u01f1\u01f2"+
		"\u00054\u0000\u0000\u01f2\u01f3\u0003(\u0014\u0000\u01f3\u01f5\u0005o"+
		"\u0000\u0000\u01f4\u01f6\u0003r9\u0000\u01f5\u01f4\u0001\u0000\u0000\u0000"+
		"\u01f5\u01f6\u0001\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000"+
		"\u01f7\u0201\u0005p\u0000\u0000\u01f8\u0202\u0003Z-\u0000\u01f9\u01fd"+
		"\u0005t\u0000\u0000\u01fa\u01fc\u0003^/\u0000\u01fb\u01fa\u0001\u0000"+
		"\u0000\u0000\u01fc\u01ff\u0001\u0000\u0000\u0000\u01fd\u01fb\u0001\u0000"+
		"\u0000\u0000\u01fd\u01fe\u0001\u0000\u0000\u0000\u01fe\u0200\u0001\u0000"+
		"\u0000\u0000\u01ff\u01fd\u0001\u0000\u0000\u0000\u0200\u0202\u0005q\u0000"+
		"\u0000\u0201\u01f8\u0001\u0000\u0000\u0000\u0201\u01f9\u0001\u0000\u0000"+
		"\u0000\u0202\'\u0001\u0000\u0000\u0000\u0203\u021e\u0005\u0081\u0000\u0000"+
		"\u0204\u021e\u0005\u0082\u0000\u0000\u0205\u021e\u0005\u0083\u0000\u0000"+
		"\u0206\u021e\u0005\u0084\u0000\u0000\u0207\u021e\u0005\u0085\u0000\u0000"+
		"\u0208\u021e\u0005\u0086\u0000\u0000\u0209\u021e\u0005\u0087\u0000\u0000"+
		"\u020a\u021e\u0005\u0088\u0000\u0000\u020b\u021e\u0005\u0089\u0000\u0000"+
		"\u020c\u021e\u0005v\u0000\u0000\u020d\u021e\u0005\u008a\u0000\u0000\u020e"+
		"\u021e\u0005\u008b\u0000\u0000\u020f\u021e\u0005}\u0000\u0000\u0210\u021e"+
		"\u0005~\u0000\u0000\u0211\u021e\u0005\u007f\u0000\u0000\u0212\u021e\u0005"+
		"\u0080\u0000\u0000\u0213\u021e\u0005{\u0000\u0000\u0214\u021e\u0005|\u0000"+
		"\u0000\u0215\u0216\u0005}\u0000\u0000\u0216\u021e\u0005}\u0000\u0000\u0217"+
		"\u0218\u0005~\u0000\u0000\u0218\u021e\u0005~\u0000\u0000\u0219\u021e\u0005"+
		"L\u0000\u0000\u021a\u021e\u0005\u0017\u0000\u0000\u021b\u021c\u0005m\u0000"+
		"\u0000\u021c\u021e\u0005n\u0000\u0000\u021d\u0203\u0001\u0000\u0000\u0000"+
		"\u021d\u0204\u0001\u0000\u0000\u0000\u021d\u0205\u0001\u0000\u0000\u0000"+
		"\u021d\u0206\u0001\u0000\u0000\u0000\u021d\u0207\u0001\u0000\u0000\u0000"+
		"\u021d\u0208\u0001\u0000\u0000\u0000\u021d\u0209\u0001\u0000\u0000\u0000"+
		"\u021d\u020a\u0001\u0000\u0000\u0000\u021d\u020b\u0001\u0000\u0000\u0000"+
		"\u021d\u020c\u0001\u0000\u0000\u0000\u021d\u020d\u0001\u0000\u0000\u0000"+
		"\u021d\u020e\u0001\u0000\u0000\u0000\u021d\u020f\u0001\u0000\u0000\u0000"+
		"\u021d\u0210\u0001\u0000\u0000\u0000\u021d\u0211\u0001\u0000\u0000\u0000"+
		"\u021d\u0212\u0001\u0000\u0000\u0000\u021d\u0213\u0001\u0000\u0000\u0000"+
		"\u021d\u0214\u0001\u0000\u0000\u0000\u021d\u0215\u0001\u0000\u0000\u0000"+
		"\u021d\u0217\u0001\u0000\u0000\u0000\u021d\u0219\u0001\u0000\u0000\u0000"+
		"\u021d\u021a\u0001\u0000\u0000\u0000\u021d\u021b\u0001\u0000\u0000\u0000"+
		"\u021e)\u0001\u0000\u0000\u0000\u021f\u0221\u0003b1\u0000\u0220\u021f"+
		"\u0001\u0000\u0000\u0000\u0221\u0224\u0001\u0000\u0000\u0000\u0222\u0220"+
		"\u0001\u0000\u0000\u0000\u0222\u0223\u0001\u0000\u0000\u0000\u0223\u0228"+
		"\u0001\u0000\u0000\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0225\u0227"+
		"\u0003~?\u0000\u0226\u0225\u0001\u0000\u0000\u0000\u0227\u022a\u0001\u0000"+
		"\u0000\u0000\u0228\u0226\u0001\u0000\u0000\u0000\u0228\u0229\u0001\u0000"+
		"\u0000\u0000\u0229\u022b\u0001\u0000\u0000\u0000\u022a\u0228\u0001\u0000"+
		"\u0000\u0000\u022b\u022c\u0007\u0004\u0000\u0000\u022c\u022d\u00054\u0000"+
		"\u0000\u022d\u022e\u00034\u001a\u0000\u022e\u0230\u0005o\u0000\u0000\u022f"+
		"\u0231\u0003r9\u0000\u0230\u022f\u0001\u0000\u0000\u0000\u0230\u0231\u0001"+
		"\u0000\u0000\u0000\u0231\u0232\u0001\u0000\u0000\u0000\u0232\u023c\u0005"+
		"p\u0000\u0000\u0233\u023d\u0003Z-\u0000\u0234\u0238\u0005t\u0000\u0000"+
		"\u0235\u0237\u0003^/\u0000\u0236\u0235\u0001\u0000\u0000\u0000\u0237\u023a"+
		"\u0001\u0000\u0000\u0000\u0238\u0236\u0001\u0000\u0000\u0000\u0238\u0239"+
		"\u0001\u0000\u0000\u0000\u0239\u023b\u0001\u0000\u0000\u0000\u023a\u0238"+
		"\u0001\u0000\u0000\u0000\u023b\u023d\u0005q\u0000\u0000\u023c\u0233\u0001"+
		"\u0000\u0000\u0000\u023c\u0234\u0001\u0000\u0000\u0000\u023d+\u0001\u0000"+
		"\u0000\u0000\u023e\u0240\u0003b1\u0000\u023f\u023e\u0001\u0000\u0000\u0000"+
		"\u0240\u0243\u0001\u0000\u0000\u0000\u0241\u023f\u0001\u0000\u0000\u0000"+
		"\u0241\u0242\u0001\u0000\u0000\u0000\u0242\u0247\u0001\u0000\u0000\u0000"+
		"\u0243\u0241\u0001\u0000\u0000\u0000\u0244\u0246\u0003~?\u0000\u0245\u0244"+
		"\u0001\u0000\u0000\u0000\u0246\u0249\u0001\u0000\u0000\u0000\u0247\u0245"+
		"\u0001\u0000\u0000\u0000\u0247\u0248\u0001\u0000\u0000\u0000\u0248\u024a"+
		"\u0001\u0000\u0000\u0000\u0249\u0247\u0001\u0000\u0000\u0000\u024a\u024b"+
		"\u0005\u0014\u0000\u0000\u024b\u024c\u00034\u001a\u0000\u024c\u0256\u0003"+
		"R)\u0000\u024d\u0251\u0005k\u0000\u0000\u024e\u0250\u0003^/\u0000\u024f"+
		"\u024e\u0001\u0000\u0000\u0000\u0250\u0253\u0001\u0000\u0000\u0000\u0251"+
		"\u024f\u0001\u0000\u0000\u0000\u0251\u0252\u0001\u0000\u0000\u0000\u0252"+
		"\u0254\u0001\u0000\u0000\u0000\u0253\u0251\u0001\u0000\u0000\u0000\u0254"+
		"\u0257\u0005l\u0000\u0000\u0255\u0257\u0005q\u0000\u0000\u0256\u024d\u0001"+
		"\u0000\u0000\u0000\u0256\u0255\u0001\u0000\u0000\u0000\u0257-\u0001\u0000"+
		"\u0000\u0000\u0258\u025a\u0003b1\u0000\u0259\u0258\u0001\u0000\u0000\u0000"+
		"\u025a\u025d\u0001\u0000\u0000\u0000\u025b\u0259\u0001\u0000\u0000\u0000"+
		"\u025b\u025c\u0001\u0000\u0000\u0000\u025c\u0261\u0001\u0000\u0000\u0000"+
		"\u025d\u025b\u0001\u0000\u0000\u0000\u025e\u0260\u0003~?\u0000\u025f\u025e"+
		"\u0001\u0000\u0000\u0000\u0260\u0263\u0001\u0000\u0000\u0000\u0261\u025f"+
		"\u0001\u0000\u0000\u0000\u0261\u0262\u0001\u0000\u0000\u0000\u0262\u0264"+
		"\u0001\u0000\u0000\u0000\u0263\u0261\u0001\u0000\u0000\u0000\u0264\u0265"+
		"\u0005\u0010\u0000\u0000\u0265\u0266\u00032\u0019\u0000\u0266\u0268\u0003"+
		"V+\u0000\u0267\u0269\u0003B!\u0000\u0268\u0267\u0001\u0000\u0000\u0000"+
		"\u0268\u0269\u0001\u0000\u0000\u0000\u0269\u026a\u0001\u0000\u0000\u0000"+
		"\u026a\u026c\u0005o\u0000\u0000\u026b\u026d\u0003r9\u0000\u026c\u026b"+
		"\u0001\u0000\u0000\u0000\u026c\u026d\u0001\u0000\u0000\u0000\u026d\u026e"+
		"\u0001\u0000\u0000\u0000\u026e\u0272\u0005p\u0000\u0000\u026f\u0271\u0003"+
		"L&\u0000\u0270\u026f\u0001\u0000\u0000\u0000\u0271\u0274\u0001\u0000\u0000"+
		"\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0272\u0273\u0001\u0000\u0000"+
		"\u0000\u0273\u0275\u0001\u0000\u0000\u0000\u0274\u0272\u0001\u0000\u0000"+
		"\u0000\u0275\u0276\u0005q\u0000\u0000\u0276/\u0001\u0000\u0000\u0000\u0277"+
		"\u0279\u0003b1\u0000\u0278\u0277\u0001\u0000\u0000\u0000\u0279\u027c\u0001"+
		"\u0000\u0000\u0000\u027a\u0278\u0001\u0000\u0000\u0000\u027a\u027b\u0001"+
		"\u0000\u0000\u0000\u027b\u0280\u0001\u0000\u0000\u0000\u027c\u027a\u0001"+
		"\u0000\u0000\u0000\u027d\u027f\u0003~?\u0000\u027e\u027d\u0001\u0000\u0000"+
		"\u0000\u027f\u0282\u0001\u0000\u0000\u0000\u0280\u027e\u0001\u0000\u0000"+
		"\u0000\u0280\u0281\u0001\u0000\u0000\u0000\u0281\u0283\u0001\u0000\u0000"+
		"\u0000\u0282\u0280\u0001\u0000\u0000\u0000\u0283\u0284\u00034\u001a\u0000"+
		"\u0284\u0285\u0005J\u0000\u0000\u0285\u0287\u0005m\u0000\u0000\u0286\u0288"+
		"\u0003r9\u0000\u0287\u0286\u0001\u0000\u0000\u0000\u0287\u0288\u0001\u0000"+
		"\u0000\u0000\u0288\u0289\u0001\u0000\u0000\u0000\u0289\u028a\u0005n\u0000"+
		"\u0000\u028a\u028b\u0003$\u0012\u0000\u028b1\u0001\u0000\u0000\u0000\u028c"+
		"\u028f\u0005T\u0000\u0000\u028d\u028f\u00034\u001a\u0000\u028e\u028c\u0001"+
		"\u0000\u0000\u0000\u028e\u028d\u0001\u0000\u0000\u0000\u028f3\u0001\u0000"+
		"\u0000\u0000\u0290\u0292\u00036\u001b\u0000\u0291\u0293\u0003>\u001f\u0000"+
		"\u0292\u0291\u0001\u0000\u0000\u0000\u0292\u0293\u0001\u0000\u0000\u0000"+
		"\u0293\u0297\u0001\u0000\u0000\u0000\u0294\u0296\u0003<\u001e\u0000\u0295"+
		"\u0294\u0001\u0000\u0000\u0000\u0296\u0299\u0001\u0000\u0000\u0000\u0297"+
		"\u0295\u0001\u0000\u0000\u0000\u0297\u0298\u0001\u0000\u0000\u0000\u0298"+
		"\u02aa\u0001\u0000\u0000\u0000\u0299\u0297\u0001\u0000\u0000\u0000\u029a"+
		"\u029b\u0005o\u0000\u0000\u029b\u029e\u0003:\u001d\u0000\u029c\u029d\u0005"+
		"r\u0000\u0000\u029d\u029f\u0003:\u001d\u0000\u029e\u029c\u0001\u0000\u0000"+
		"\u0000\u029f\u02a0\u0001\u0000\u0000\u0000\u02a0\u029e\u0001\u0000\u0000"+
		"\u0000\u02a0\u02a1\u0001\u0000\u0000\u0000\u02a1\u02a2\u0001\u0000\u0000"+
		"\u0000\u02a2\u02a6\u0005p\u0000\u0000\u02a3\u02a5\u0003<\u001e\u0000\u02a4"+
		"\u02a3\u0001\u0000\u0000\u0000\u02a5\u02a8\u0001\u0000\u0000\u0000\u02a6"+
		"\u02a4\u0001\u0000\u0000\u0000\u02a6\u02a7\u0001\u0000\u0000\u0000\u02a7"+
		"\u02aa\u0001\u0000\u0000\u0000\u02a8\u02a6\u0001\u0000\u0000\u0000\u02a9"+
		"\u0290\u0001\u0000\u0000\u0000\u02a9\u029a\u0001\u0000\u0000\u0000\u02aa"+
		"5\u0001\u0000\u0000\u0000\u02ab\u02ae\u0003T*\u0000\u02ac\u02ae\u0003"+
		"8\u001c\u0000\u02ad\u02ab\u0001\u0000\u0000\u0000\u02ad\u02ac\u0001\u0000"+
		"\u0000\u0000\u02ae7\u0001\u0000\u0000\u0000\u02af\u02b0\u0007\u0005\u0000"+
		"\u0000\u02b09\u0001\u0000\u0000\u0000\u02b1\u02b3\u00034\u001a\u0000\u02b2"+
		"\u02b4\u0005\u00a3\u0000\u0000\u02b3\u02b2\u0001\u0000\u0000\u0000\u02b3"+
		"\u02b4\u0001\u0000\u0000\u0000\u02b4;\u0001\u0000\u0000\u0000\u02b5\u02c0"+
		"\u0005w\u0000\u0000\u02b6\u02c0\u0005\u0083\u0000\u0000\u02b7\u02bb\u0005"+
		"m\u0000\u0000\u02b8\u02ba\u0005r\u0000\u0000\u02b9\u02b8\u0001\u0000\u0000"+
		"\u0000\u02ba\u02bd\u0001\u0000\u0000\u0000\u02bb\u02b9\u0001\u0000\u0000"+
		"\u0000\u02bb\u02bc\u0001\u0000\u0000\u0000\u02bc\u02be\u0001\u0000\u0000"+
		"\u0000\u02bd\u02bb\u0001\u0000\u0000\u0000\u02be\u02c0\u0005n\u0000\u0000"+
		"\u02bf\u02b5\u0001\u0000\u0000\u0000\u02bf\u02b6\u0001\u0000\u0000\u0000"+
		"\u02bf\u02b7\u0001\u0000\u0000\u0000\u02c0=\u0001\u0000\u0000\u0000\u02c1"+
		"\u02c2\u0005}\u0000\u0000\u02c2\u02c7\u0003@ \u0000\u02c3\u02c4\u0005"+
		"r\u0000\u0000\u02c4\u02c6\u0003@ \u0000\u02c5\u02c3\u0001\u0000\u0000"+
		"\u0000\u02c6\u02c9\u0001\u0000\u0000\u0000\u02c7\u02c5\u0001\u0000\u0000"+
		"\u0000\u02c7\u02c8\u0001\u0000\u0000\u0000\u02c8\u02ca\u0001\u0000\u0000"+
		"\u0000\u02c9\u02c7\u0001\u0000\u0000\u0000\u02ca\u02cb\u0005~\u0000\u0000"+
		"\u02cb?\u0001\u0000\u0000\u0000\u02cc\u02cf\u00034\u001a\u0000\u02cd\u02cf"+
		"\u0005w\u0000\u0000\u02ce\u02cc\u0001\u0000\u0000\u0000\u02ce\u02cd\u0001"+
		"\u0000\u0000\u0000\u02cfA\u0001\u0000\u0000\u0000\u02d0\u02d1\u0005}\u0000"+
		"\u0000\u02d1\u02d6\u0003D\"\u0000\u02d2\u02d3\u0005r\u0000\u0000\u02d3"+
		"\u02d5\u0003D\"\u0000\u02d4\u02d2\u0001\u0000\u0000\u0000\u02d5\u02d8"+
		"\u0001\u0000\u0000\u0000\u02d6\u02d4\u0001\u0000\u0000\u0000\u02d6\u02d7"+
		"\u0001\u0000\u0000\u0000\u02d7\u02d9\u0001\u0000\u0000\u0000\u02d8\u02d6"+
		"\u0001\u0000\u0000\u0000\u02d9\u02da\u0005~\u0000\u0000\u02daC\u0001\u0000"+
		"\u0000\u0000\u02db\u02dd\u0003b1\u0000\u02dc\u02db\u0001\u0000\u0000\u0000"+
		"\u02dd\u02e0\u0001\u0000\u0000\u0000\u02de\u02dc\u0001\u0000\u0000\u0000"+
		"\u02de\u02df\u0001\u0000\u0000\u0000\u02df\u02e2\u0001\u0000\u0000\u0000"+
		"\u02e0\u02de\u0001\u0000\u0000\u0000\u02e1\u02e3\u0007\u0006\u0000\u0000"+
		"\u02e2\u02e1\u0001\u0000\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000\u0000"+
		"\u02e3\u02e4\u0001\u0000\u0000\u0000\u02e4\u02e5\u0003V+\u0000\u02e5E"+
		"\u0001\u0000\u0000\u0000\u02e6\u02eb\u00034\u001a\u0000\u02e7\u02e8\u0005"+
		"r\u0000\u0000\u02e8\u02ea\u00034\u001a\u0000\u02e9\u02e7\u0001\u0000\u0000"+
		"\u0000\u02ea\u02ed\u0001\u0000\u0000\u0000\u02eb\u02e9\u0001\u0000\u0000"+
		"\u0000\u02eb\u02ec\u0001\u0000\u0000\u0000\u02ecG\u0001\u0000\u0000\u0000"+
		"\u02ed\u02eb\u0001\u0000\u0000\u0000\u02ee\u02f3\u0003J%\u0000\u02ef\u02f0"+
		"\u0005r\u0000\u0000\u02f0\u02f2\u0003J%\u0000\u02f1\u02ef\u0001\u0000"+
		"\u0000\u0000\u02f2\u02f5\u0001\u0000\u0000\u0000\u02f3\u02f1\u0001\u0000"+
		"\u0000\u0000\u02f3\u02f4\u0001\u0000\u0000\u0000\u02f4I\u0001\u0000\u0000"+
		"\u0000\u02f5\u02f3\u0001\u0000\u0000\u0000\u02f6\u02ff\u00034\u001a\u0000"+
		"\u02f7\u02fb\u0005o\u0000\u0000\u02f8\u02fa\u0003`0\u0000\u02f9\u02f8"+
		"\u0001\u0000\u0000\u0000\u02fa\u02fd\u0001\u0000\u0000\u0000\u02fb\u02f9"+
		"\u0001\u0000\u0000\u0000\u02fb\u02fc\u0001\u0000\u0000\u0000\u02fc\u02fe"+
		"\u0001\u0000\u0000\u0000\u02fd\u02fb\u0001\u0000\u0000\u0000\u02fe\u0300"+
		"\u0005p\u0000\u0000\u02ff\u02f7\u0001\u0000\u0000\u0000\u02ff\u0300\u0001"+
		"\u0000\u0000\u0000\u0300K\u0001\u0000\u0000\u0000\u0301\u0302\u0005V\u0000"+
		"\u0000\u0302\u0303\u0003V+\u0000\u0303\u0304\u0005x\u0000\u0000\u0304"+
		"\u0305\u0003N\'\u0000\u0305M\u0001\u0000\u0000\u0000\u0306\u030b\u0003"+
		"P(\u0000\u0307\u0308\u0005r\u0000\u0000\u0308\u030a\u0003P(\u0000\u0309"+
		"\u0307\u0001\u0000\u0000\u0000\u030a\u030d\u0001\u0000\u0000\u0000\u030b"+
		"\u0309\u0001\u0000\u0000\u0000\u030b\u030c\u0001\u0000\u0000\u0000\u030c"+
		"O\u0001\u0000\u0000\u0000\u030d\u030b\u0001\u0000\u0000\u0000\u030e\u030f"+
		"\u00050\u0000\u0000\u030f\u0310\u0005o\u0000\u0000\u0310\u031b\u0005p"+
		"\u0000\u0000\u0311\u0313\u0005\f\u0000\u0000\u0312\u0314\u0005w\u0000"+
		"\u0000\u0313\u0312\u0001\u0000\u0000\u0000\u0313\u0314\u0001\u0000\u0000"+
		"\u0000\u0314\u031b\u0001\u0000\u0000\u0000\u0315\u031b\u0005H\u0000\u0000"+
		"\u0316\u031b\u00051\u0000\u0000\u0317\u031b\u0005O\u0000\u0000\u0318\u031b"+
		"\u0005\u000f\u0000\u0000\u0319\u031b\u00034\u001a\u0000\u031a\u030e\u0001"+
		"\u0000\u0000\u0000\u031a\u0311\u0001\u0000\u0000\u0000\u031a\u0315\u0001"+
		"\u0000\u0000\u0000\u031a\u0316\u0001\u0000\u0000\u0000\u031a\u0317\u0001"+
		"\u0000\u0000\u0000\u031a\u0318\u0001\u0000\u0000\u0000\u031a\u0319\u0001"+
		"\u0000\u0000\u0000\u031bQ\u0001\u0000\u0000\u0000\u031c\u0321\u0003V+"+
		"\u0000\u031d\u031e\u0005s\u0000\u0000\u031e\u0320\u0003V+\u0000\u031f"+
		"\u031d\u0001\u0000\u0000\u0000\u0320\u0323\u0001\u0000\u0000\u0000\u0321"+
		"\u031f\u0001\u0000\u0000\u0000\u0321\u0322\u0001\u0000\u0000\u0000\u0322"+
		"S\u0001\u0000\u0000\u0000\u0323\u0321\u0001\u0000\u0000\u0000\u0324\u0329"+
		"\u0003V+\u0000\u0325\u0326\u0007\u0007\u0000\u0000\u0326\u0328\u0003V"+
		"+\u0000\u0327\u0325\u0001\u0000\u0000\u0000\u0328\u032b\u0001\u0000\u0000"+
		"\u0000\u0329\u0327\u0001\u0000\u0000\u0000\u0329\u032a\u0001\u0000\u0000"+
		"\u0000\u032aU\u0001\u0000\u0000\u0000\u032b\u0329\u0001\u0000\u0000\u0000"+
		"\u032c\u032d\u0007\b\u0000\u0000\u032dW\u0001\u0000\u0000\u0000\u032e"+
		"\u0339\u0003Z-\u0000\u032f\u0333\u0005t\u0000\u0000\u0330\u0332\u0003"+
		"^/\u0000\u0331\u0330\u0001\u0000\u0000\u0000\u0332\u0335\u0001\u0000\u0000"+
		"\u0000\u0333\u0331\u0001\u0000\u0000\u0000\u0333\u0334\u0001\u0000\u0000"+
		"\u0000\u0334\u0336\u0001\u0000\u0000\u0000\u0335\u0333\u0001\u0000\u0000"+
		"\u0000\u0336\u0339\u0005q\u0000\u0000\u0337\u0339\u0005q\u0000\u0000\u0338"+
		"\u032e\u0001\u0000\u0000\u0000\u0338\u032f\u0001\u0000\u0000\u0000\u0338"+
		"\u0337\u0001\u0000\u0000\u0000\u0339Y\u0001\u0000\u0000\u0000\u033a\u033e"+
		"\u0005k\u0000\u0000\u033b\u033d\u0003\\.\u0000\u033c\u033b\u0001\u0000"+
		"\u0000\u0000\u033d\u0340\u0001\u0000\u0000\u0000\u033e\u033c\u0001\u0000"+
		"\u0000\u0000\u033e\u033f\u0001\u0000\u0000\u0000\u033f\u0341\u0001\u0000"+
		"\u0000\u0000\u0340\u033e\u0001\u0000\u0000\u0000\u0341\u0342\u0005l\u0000"+
		"\u0000\u0342[\u0001\u0000\u0000\u0000\u0343\u0356\u0003Z-\u0000\u0344"+
		"\u0348\u0005m\u0000\u0000\u0345\u0347\u0003`0\u0000\u0346\u0345\u0001"+
		"\u0000\u0000\u0000\u0347\u034a\u0001\u0000\u0000\u0000\u0348\u0346\u0001"+
		"\u0000\u0000\u0000\u0348\u0349\u0001\u0000\u0000\u0000\u0349\u034b\u0001"+
		"\u0000\u0000\u0000\u034a\u0348\u0001\u0000\u0000\u0000\u034b\u0356\u0005"+
		"n\u0000\u0000\u034c\u0350\u0005o\u0000\u0000\u034d\u034f\u0003`0\u0000"+
		"\u034e\u034d\u0001\u0000\u0000\u0000\u034f\u0352\u0001\u0000\u0000\u0000"+
		"\u0350\u034e\u0001\u0000\u0000\u0000\u0350\u0351\u0001\u0000\u0000\u0000"+
		"\u0351\u0353\u0001\u0000\u0000\u0000\u0352\u0350\u0001\u0000\u0000\u0000"+
		"\u0353\u0356\u0005p\u0000\u0000\u0354\u0356\b\t\u0000\u0000\u0355\u0343"+
		"\u0001\u0000\u0000\u0000\u0355\u0344\u0001\u0000\u0000\u0000\u0355\u034c"+
		"\u0001\u0000\u0000\u0000\u0355\u0354\u0001\u0000\u0000\u0000\u0356]\u0001"+
		"\u0000\u0000\u0000\u0357\u036a\u0003Z-\u0000\u0358\u035c\u0005m\u0000"+
		"\u0000\u0359\u035b\u0003`0\u0000\u035a\u0359\u0001\u0000\u0000\u0000\u035b"+
		"\u035e\u0001\u0000\u0000\u0000\u035c\u035a\u0001\u0000\u0000\u0000\u035c"+
		"\u035d\u0001\u0000\u0000\u0000\u035d\u035f\u0001\u0000\u0000\u0000\u035e"+
		"\u035c\u0001\u0000\u0000\u0000\u035f\u036a\u0005n\u0000\u0000\u0360\u0364"+
		"\u0005o\u0000\u0000\u0361\u0363\u0003`0\u0000\u0362\u0361\u0001\u0000"+
		"\u0000\u0000\u0363\u0366\u0001\u0000\u0000\u0000\u0364\u0362\u0001\u0000"+
		"\u0000\u0000\u0364\u0365\u0001\u0000\u0000\u0000\u0365\u0367\u0001\u0000"+
		"\u0000\u0000\u0366\u0364\u0001\u0000\u0000\u0000\u0367\u036a\u0005p\u0000"+
		"\u0000\u0368\u036a\b\t\u0000\u0000\u0369\u0357\u0001\u0000\u0000\u0000"+
		"\u0369\u0358\u0001\u0000\u0000\u0000\u0369\u0360\u0001\u0000\u0000\u0000"+
		"\u0369\u0368\u0001\u0000\u0000\u0000\u036a_\u0001\u0000\u0000\u0000\u036b"+
		"\u036f\u0005k\u0000\u0000\u036c\u036e\u0003`0\u0000\u036d\u036c\u0001"+
		"\u0000\u0000\u0000\u036e\u0371\u0001\u0000\u0000\u0000\u036f\u036d\u0001"+
		"\u0000\u0000\u0000\u036f\u0370\u0001\u0000\u0000\u0000\u0370\u0372\u0001"+
		"\u0000\u0000\u0000\u0371\u036f\u0001\u0000\u0000\u0000\u0372\u0385\u0005"+
		"l\u0000\u0000\u0373\u0377\u0005m\u0000\u0000\u0374\u0376\u0003`0\u0000"+
		"\u0375\u0374\u0001\u0000\u0000\u0000\u0376\u0379\u0001\u0000\u0000\u0000"+
		"\u0377\u0375\u0001\u0000\u0000\u0000\u0377\u0378\u0001\u0000\u0000\u0000"+
		"\u0378\u037a\u0001\u0000\u0000\u0000\u0379\u0377\u0001\u0000\u0000\u0000"+
		"\u037a\u0385\u0005n\u0000\u0000\u037b\u037f\u0005o\u0000\u0000\u037c\u037e"+
		"\u0003`0\u0000\u037d\u037c\u0001\u0000\u0000\u0000\u037e\u0381\u0001\u0000"+
		"\u0000\u0000\u037f\u037d\u0001\u0000\u0000\u0000\u037f\u0380\u0001\u0000"+
		"\u0000\u0000\u0380\u0382\u0001\u0000\u0000\u0000\u0381\u037f\u0001\u0000"+
		"\u0000\u0000\u0382\u0385\u0005p\u0000\u0000\u0383\u0385\b\t\u0000\u0000"+
		"\u0384\u036b\u0001\u0000\u0000\u0000\u0384\u0373\u0001\u0000\u0000\u0000"+
		"\u0384\u037b\u0001\u0000\u0000\u0000\u0384\u0383\u0001\u0000\u0000\u0000"+
		"\u0385a\u0001\u0000\u0000\u0000\u0386\u038a\u0005m\u0000\u0000\u0387\u0388"+
		"\u0003d2\u0000\u0388\u0389\u0005x\u0000\u0000\u0389\u038b\u0001\u0000"+
		"\u0000\u0000\u038a\u0387\u0001\u0000\u0000\u0000\u038a\u038b\u0001\u0000"+
		"\u0000\u0000\u038b\u038c\u0001\u0000\u0000\u0000\u038c\u038d\u0003f3\u0000"+
		"\u038d\u038e\u0005n\u0000\u0000\u038ec\u0001\u0000\u0000\u0000\u038f\u0390"+
		"\u0007\n\u0000\u0000\u0390e\u0001\u0000\u0000\u0000\u0391\u0396\u0003"+
		"h4\u0000\u0392\u0393\u0005r\u0000\u0000\u0393\u0395\u0003h4\u0000\u0394"+
		"\u0392\u0001\u0000\u0000\u0000\u0395\u0398\u0001\u0000\u0000\u0000\u0396"+
		"\u0394\u0001\u0000\u0000\u0000\u0396\u0397\u0001\u0000\u0000\u0000\u0397"+
		"g\u0001\u0000\u0000\u0000\u0398\u0396\u0001\u0000\u0000\u0000\u0399\u039f"+
		"\u0003T*\u0000\u039a\u039c\u0005o\u0000\u0000\u039b\u039d\u0003j5\u0000"+
		"\u039c\u039b\u0001\u0000\u0000\u0000\u039c\u039d\u0001\u0000\u0000\u0000"+
		"\u039d\u039e\u0001\u0000\u0000\u0000\u039e\u03a0\u0005p\u0000\u0000\u039f"+
		"\u039a\u0001\u0000\u0000\u0000\u039f\u03a0\u0001\u0000\u0000\u0000\u03a0"+
		"i\u0001\u0000\u0000\u0000\u03a1\u03a6\u0003l6\u0000\u03a2\u03a3\u0005"+
		"r\u0000\u0000\u03a3\u03a5\u0003l6\u0000\u03a4\u03a2\u0001\u0000\u0000"+
		"\u0000\u03a5\u03a8\u0001\u0000\u0000\u0000\u03a6\u03a4\u0001\u0000\u0000"+
		"\u0000\u03a6\u03a7\u0001\u0000\u0000\u0000\u03a7k\u0001\u0000\u0000\u0000"+
		"\u03a8\u03a6\u0001\u0000\u0000\u0000\u03a9\u03aa\u0003V+\u0000\u03aa\u03ab"+
		"\u0005z\u0000\u0000\u03ab\u03ac\u0003n7\u0000\u03ac\u03af\u0001\u0000"+
		"\u0000\u0000\u03ad\u03af\u0003n7\u0000\u03ae\u03a9\u0001\u0000\u0000\u0000"+
		"\u03ae\u03ad\u0001\u0000\u0000\u0000\u03afm\u0001\u0000\u0000\u0000\u03b0"+
		"\u03b1\u00067\uffff\uffff\u0000\u03b1\u03de\u0003p8\u0000\u03b2\u03de"+
		"\u0005\u009f\u0000\u0000\u03b3\u03de\u0005L\u0000\u0000\u03b4\u03de\u0005"+
		"\u0017\u0000\u0000\u03b5\u03de\u00052\u0000\u0000\u03b6\u03b8\u0005\u0082"+
		"\u0000\u0000\u03b7\u03b6\u0001\u0000\u0000\u0000\u03b7\u03b8\u0001\u0000"+
		"\u0000\u0000\u03b8\u03b9\u0001\u0000\u0000\u0000\u03b9\u03de\u0005\u00a0"+
		"\u0000\u0000\u03ba\u03bc\u0005\u0082\u0000\u0000\u03bb\u03ba\u0001\u0000"+
		"\u0000\u0000\u03bb\u03bc\u0001\u0000\u0000\u0000\u03bc\u03bd\u0001\u0000"+
		"\u0000\u0000\u03bd\u03de\u0005\u00a1\u0000\u0000\u03be\u03de\u0003T*\u0000"+
		"\u03bf\u03c0\u0005N\u0000\u0000\u03c0\u03c1\u0005o\u0000\u0000\u03c1\u03c2"+
		"\u00034\u001a\u0000\u03c2\u03c3\u0005p\u0000\u0000\u03c3\u03de\u0001\u0000"+
		"\u0000\u0000\u03c4\u03c5\u0005.\u0000\u0000\u03c5\u03c6\u0005o\u0000\u0000"+
		"\u03c6\u03c7\u0003T*\u0000\u03c7\u03c8\u0005p\u0000\u0000\u03c8\u03de"+
		"\u0001\u0000\u0000\u0000\u03c9\u03ca\u00050\u0000\u0000\u03ca\u03cd\u0003"+
		"T*\u0000\u03cb\u03cc\u0005m\u0000\u0000\u03cc\u03ce\u0005n\u0000\u0000"+
		"\u03cd\u03cb\u0001\u0000\u0000\u0000\u03cd\u03ce\u0001\u0000\u0000\u0000"+
		"\u03ce\u03cf\u0001\u0000\u0000\u0000\u03cf\u03d1\u0005o\u0000\u0000\u03d0"+
		"\u03d2\u0003j5\u0000\u03d1\u03d0\u0001\u0000\u0000\u0000\u03d1\u03d2\u0001"+
		"\u0000\u0000\u0000\u03d2\u03d3\u0001\u0000\u0000\u0000\u03d3\u03d4\u0005"+
		"p\u0000\u0000\u03d4\u03de\u0001\u0000\u0000\u0000\u03d5\u03d9\u0005o\u0000"+
		"\u0000\u03d6\u03d8\u0003`0\u0000\u03d7\u03d6\u0001\u0000\u0000\u0000\u03d8"+
		"\u03db\u0001\u0000\u0000\u0000\u03d9\u03d7\u0001\u0000\u0000\u0000\u03d9"+
		"\u03da\u0001\u0000\u0000\u0000\u03da\u03dc\u0001\u0000\u0000\u0000\u03db"+
		"\u03d9\u0001\u0000\u0000\u0000\u03dc\u03de\u0005p\u0000\u0000\u03dd\u03b0"+
		"\u0001\u0000\u0000\u0000\u03dd\u03b2\u0001\u0000\u0000\u0000\u03dd\u03b3"+
		"\u0001\u0000\u0000\u0000\u03dd\u03b4\u0001\u0000\u0000\u0000\u03dd\u03b5"+
		"\u0001\u0000\u0000\u0000\u03dd\u03b7\u0001\u0000\u0000\u0000\u03dd\u03bb"+
		"\u0001\u0000\u0000\u0000\u03dd\u03be\u0001\u0000\u0000\u0000\u03dd\u03bf"+
		"\u0001\u0000\u0000\u0000\u03dd\u03c4\u0001\u0000\u0000\u0000\u03dd\u03c9"+
		"\u0001\u0000\u0000\u0000\u03dd\u03d5\u0001\u0000\u0000\u0000\u03de\u03e7"+
		"\u0001\u0000\u0000\u0000\u03df\u03e0\n\u000e\u0000\u0000\u03e0\u03e1\u0005"+
		"\u0087\u0000\u0000\u03e1\u03e6\u0003n7\u000f\u03e2\u03e3\n\r\u0000\u0000"+
		"\u03e3\u03e4\u0005\u0081\u0000\u0000\u03e4\u03e6\u0003n7\u000e\u03e5\u03df"+
		"\u0001\u0000\u0000\u0000\u03e5\u03e2\u0001\u0000\u0000\u0000\u03e6\u03e9"+
		"\u0001\u0000\u0000\u0000\u03e7\u03e5\u0001\u0000\u0000\u0000\u03e7\u03e8"+
		"\u0001\u0000\u0000\u0000\u03e8o\u0001\u0000\u0000\u0000\u03e9\u03e7\u0001"+
		"\u0000\u0000\u0000\u03ea\u03eb\u0007\u000b\u0000\u0000\u03ebq\u0001\u0000"+
		"\u0000\u0000\u03ec\u03f1\u0003t:\u0000\u03ed\u03ee\u0005r\u0000\u0000"+
		"\u03ee\u03f0\u0003t:\u0000\u03ef\u03ed\u0001\u0000\u0000\u0000\u03f0\u03f3"+
		"\u0001\u0000\u0000\u0000\u03f1\u03ef\u0001\u0000\u0000\u0000\u03f1\u03f2"+
		"\u0001\u0000\u0000\u0000\u03f2s\u0001\u0000\u0000\u0000\u03f3\u03f1\u0001"+
		"\u0000\u0000\u0000\u03f4\u03f6\u0003b1\u0000\u03f5\u03f4\u0001\u0000\u0000"+
		"\u0000\u03f6\u03f9\u0001\u0000\u0000\u0000\u03f7\u03f5\u0001\u0000\u0000"+
		"\u0000\u03f7\u03f8\u0001\u0000\u0000\u0000\u03f8\u03fd\u0001\u0000\u0000"+
		"\u0000\u03f9\u03f7\u0001\u0000\u0000\u0000\u03fa\u03fc\u0003v;\u0000\u03fb"+
		"\u03fa\u0001\u0000\u0000\u0000\u03fc\u03ff\u0001\u0000\u0000\u0000\u03fd"+
		"\u03fb\u0001\u0000\u0000\u0000\u03fd\u03fe\u0001\u0000\u0000\u0000\u03fe"+
		"\u0400\u0001\u0000\u0000\u0000\u03ff\u03fd\u0001\u0000\u0000\u0000\u0400"+
		"\u0402\u00034\u001a\u0000\u0401\u0403\u0003V+\u0000\u0402\u0401\u0001"+
		"\u0000\u0000\u0000\u0402\u0403\u0001\u0000\u0000\u0000\u0403\u0406\u0001"+
		"\u0000\u0000\u0000\u0404\u0405\u0005z\u0000\u0000\u0405\u0407\u0003x<"+
		"\u0000\u0406\u0404\u0001\u0000\u0000\u0000\u0406\u0407\u0001\u0000\u0000"+
		"\u0000\u0407u\u0001\u0000\u0000\u0000\u0408\u0409\u0007\f\u0000\u0000"+
		"\u0409w\u0001\u0000\u0000\u0000\u040a\u0436\u0003p8\u0000\u040b\u0436"+
		"\u0005\u009f\u0000\u0000\u040c\u0436\u0005L\u0000\u0000\u040d\u0436\u0005"+
		"\u0017\u0000\u0000\u040e\u0436\u00052\u0000\u0000\u040f\u0411\u0005\u0082"+
		"\u0000\u0000\u0410\u040f\u0001\u0000\u0000\u0000\u0410\u0411\u0001\u0000"+
		"\u0000\u0000\u0411\u0412\u0001\u0000\u0000\u0000\u0412\u0436\u0005\u00a0"+
		"\u0000\u0000\u0413\u0415\u0005\u0082\u0000\u0000\u0414\u0413\u0001\u0000"+
		"\u0000\u0000\u0414\u0415\u0001\u0000\u0000\u0000\u0415\u0416\u0001\u0000"+
		"\u0000\u0000\u0416\u0436\u0005\u00a1\u0000\u0000\u0417\u0436\u0003T*\u0000"+
		"\u0418\u0419\u00050\u0000\u0000\u0419\u041b\u0003T*\u0000\u041a\u041c"+
		"\u0003>\u001f\u0000\u041b\u041a\u0001\u0000\u0000\u0000\u041b\u041c\u0001"+
		"\u0000\u0000\u0000\u041c\u041d\u0001\u0000\u0000\u0000\u041d\u0421\u0005"+
		"o\u0000\u0000\u041e\u0420\u0003`0\u0000\u041f\u041e\u0001\u0000\u0000"+
		"\u0000\u0420\u0423\u0001\u0000\u0000\u0000\u0421\u041f\u0001\u0000\u0000"+
		"\u0000\u0421\u0422\u0001\u0000\u0000\u0000\u0422\u0424\u0001\u0000\u0000"+
		"\u0000\u0423\u0421\u0001\u0000\u0000\u0000\u0424\u0425\u0005p\u0000\u0000"+
		"\u0425\u0436\u0001\u0000\u0000\u0000\u0426\u042b\u0005\u000f\u0000\u0000"+
		"\u0427\u0428\u0005o\u0000\u0000\u0428\u0429\u00034\u001a\u0000\u0429\u042a"+
		"\u0005p\u0000\u0000\u042a\u042c\u0001\u0000\u0000\u0000\u042b\u0427\u0001"+
		"\u0000\u0000\u0000\u042b\u042c\u0001\u0000\u0000\u0000\u042c\u0436\u0001"+
		"\u0000\u0000\u0000\u042d\u0431\u0005o\u0000\u0000\u042e\u0430\u0003`0"+
		"\u0000\u042f\u042e\u0001\u0000\u0000\u0000\u0430\u0433\u0001\u0000\u0000"+
		"\u0000\u0431\u042f\u0001\u0000\u0000\u0000\u0431\u0432\u0001\u0000\u0000"+
		"\u0000\u0432\u0434\u0001\u0000\u0000\u0000\u0433\u0431\u0001\u0000\u0000"+
		"\u0000\u0434\u0436\u0005p\u0000\u0000\u0435\u040a\u0001\u0000\u0000\u0000"+
		"\u0435\u040b\u0001\u0000\u0000\u0000\u0435\u040c\u0001\u0000\u0000\u0000"+
		"\u0435\u040d\u0001\u0000\u0000\u0000\u0435\u040e\u0001\u0000\u0000\u0000"+
		"\u0435\u0410\u0001\u0000\u0000\u0000\u0435\u0414\u0001\u0000\u0000\u0000"+
		"\u0435\u0417\u0001\u0000\u0000\u0000\u0435\u0418\u0001\u0000\u0000\u0000"+
		"\u0435\u0426\u0001\u0000\u0000\u0000\u0435\u042d\u0001\u0000\u0000\u0000"+
		"\u0436y\u0001\u0000\u0000\u0000\u0437\u043c\u0003|>\u0000\u0438\u0439"+
		"\u0005r\u0000\u0000\u0439\u043b\u0003|>\u0000\u043a\u0438\u0001\u0000"+
		"\u0000\u0000\u043b\u043e\u0001\u0000\u0000\u0000\u043c\u043a\u0001\u0000"+
		"\u0000\u0000\u043c\u043d\u0001\u0000\u0000\u0000\u043d{\u0001\u0000\u0000"+
		"\u0000\u043e\u043c\u0001\u0000\u0000\u0000\u043f\u0440\u0003V+\u0000\u0440"+
		"\u0441\u0005x\u0000\u0000\u0441\u0443\u0001\u0000\u0000\u0000\u0442\u043f"+
		"\u0001\u0000\u0000\u0000\u0442\u0443\u0001\u0000\u0000\u0000\u0443\u0445"+
		"\u0001\u0000\u0000\u0000\u0444\u0446\u0007\r\u0000\u0000\u0445\u0444\u0001"+
		"\u0000\u0000\u0000\u0445\u0446\u0001\u0000\u0000\u0000\u0446\u0447\u0001"+
		"\u0000\u0000\u0000\u0447\u0448\u0003T*\u0000\u0448}\u0001\u0000\u0000"+
		"\u0000\u0449\u044a\u0007\u000e\u0000\u0000\u044a\u007f\u0001\u0000\u0000"+
		"\u0000\u0092\u0083\u0089\u008f\u0096\u0099\u00a3\u00a7\u00ac\u00b3\u00bb"+
		"\u00bf\u00cd\u00d4\u00dc\u00e2\u00ea\u00f0\u00f6\u00fa\u00fd\u0101\u0106"+
		"\u010d\u0112\u0119\u011b\u0120\u0126\u012d\u0133\u013d\u0141\u014e\u0153"+
		"\u0159\u015f\u0163\u0169\u0171\u0177\u017d\u0181\u0188\u018c\u0194\u019c"+
		"\u01a2\u01ae\u01b4\u01b8\u01c2\u01ca\u01ce\u01d4\u01dc\u01df\u01e2\u01e7"+
		"\u01ed\u01f5\u01fd\u0201\u021d\u0222\u0228\u0230\u0238\u023c\u0241\u0247"+
		"\u0251\u0256\u025b\u0261\u0268\u026c\u0272\u027a\u0280\u0287\u028e\u0292"+
		"\u0297\u02a0\u02a6\u02a9\u02ad\u02b3\u02bb\u02bf\u02c7\u02ce\u02d6\u02de"+
		"\u02e2\u02eb\u02f3\u02fb\u02ff\u030b\u0313\u031a\u0321\u0329\u0333\u0338"+
		"\u033e\u0348\u0350\u0355\u035c\u0364\u0369\u036f\u0377\u037f\u0384\u038a"+
		"\u0396\u039c\u039f\u03a6\u03ae\u03b7\u03bb\u03cd\u03d1\u03d9\u03dd\u03e5"+
		"\u03e7\u03f1\u03f7\u03fd\u0402\u0406\u0410\u0414\u041b\u0421\u042b\u0431"+
		"\u0435\u043c\u0442\u0445";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}