CSharpPreprocessorParser.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     ANTLR Version: 4.9.3
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

// Generated from CSharpPreprocessorParser.g4 by ANTLR 4.9.3

// Unreachable code detected
#pragma warning disable 0162
// The variable '...' is assigned but its value is never used
#pragma warning disable 0219
// Missing XML comment for publicly visible type or member '...'
#pragma warning disable 1591
// Ambiguous reference in cref attribute
#pragma warning disable 419

using System;
using System.IO;
using System.Text;
using System.Diagnostics;
using System.Collections.Generic;
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Antlr4.Runtime.Tree;
using DFA = Antlr4.Runtime.Dfa.DFA;

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

	private static readonly string[] _LiteralNames = {
		null, "'\u00EF\u00BB\u00BF'", null, "'/***/'", null, null, null, null, 
		"'#'", "'abstract'", "'add'", "'alias'", "'__arglist'", "'as'", "'ascending'", 
		"'async'", "'await'", "'base'", "'bool'", "'break'", "'by'", "'byte'", 
		"'case'", "'catch'", "'char'", "'checked'", "'class'", "'const'", "'continue'", 
		"'decimal'", "'default'", "'delegate'", "'descending'", "'do'", "'double'", 
		"'dynamic'", "'else'", "'enum'", "'equals'", "'event'", "'explicit'", 
		"'extern'", "'false'", "'finally'", "'fixed'", "'float'", "'for'", "'foreach'", 
		"'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'", "'in'", 
		"'int'", "'interface'", "'internal'", "'into'", "'is'", "'join'", "'let'", 
		"'lock'", "'long'", "'nameof'", "'namespace'", "'new'", "'null'", "'object'", 
		"'on'", "'operator'", "'orderby'", "'out'", "'override'", "'params'", 
		"'partial'", "'private'", "'protected'", "'public'", "'readonly'", "'ref'", 
		"'remove'", "'return'", "'sbyte'", "'sealed'", "'select'", "'set'", "'short'", 
		"'sizeof'", "'stackalloc'", "'static'", "'string'", "'struct'", "'switch'", 
		"'this'", "'throw'", "'true'", "'try'", "'typeof'", "'uint'", "'ulong'", 
		"'unchecked'", "'unmanaged'", "'unsafe'", "'ushort'", "'using'", "'var'", 
		"'virtual'", "'void'", "'volatile'", "'when'", "'where'", "'while'", "'yield'", 
		null, null, null, null, null, null, null, null, null, null, null, "'{'", 
		"'}'", "'['", "']'", "'('", "')'", "'.'", "','", "':'", "';'", "'+'", 
		"'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'", "'!'", "'~'", "'='", 
		"'<'", "'>'", "'?'", "'::'", "'??'", "'++'", "'--'", "'&&'", "'||'", "'->'", 
		"'=='", "'!='", "'<='", "'>='", "'+='", "'-='", "'*='", "'/='", "'%='", 
		"'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'", "'{{'", null, 
		null, null, null, null, null, null, null, null, null, "'define'", "'undef'", 
		"'elif'", "'endif'", "'line'", null, null, null, null, null, null, "'hidden'", 
		null, null, null, "'}}'"
	};
	private static readonly string[] _SymbolicNames = {
		null, "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT", "EMPTY_DELIMITED_DOC_COMMENT", 
		"DELIMITED_DOC_COMMENT", "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", "WHITESPACES", 
		"SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS", "ASCENDING", "ASYNC", 
		"AWAIT", "BASE", "BOOL", "BREAK", "BY", "BYTE", "CASE", "CATCH", "CHAR", 
		"CHECKED", "CLASS", "CONST", "CONTINUE", "DECIMAL", "DEFAULT", "DELEGATE", 
		"DESCENDING", "DO", "DOUBLE", "DYNAMIC", "ELSE", "ENUM", "EQUALS", "EVENT", 
		"EXPLICIT", "EXTERN", "FALSE", "FINALLY", "FIXED", "FLOAT", "FOR", "FOREACH", 
		"FROM", "GET", "GOTO", "GROUP", "IF", "IMPLICIT", "IN", "INT", "INTERFACE", 
		"INTERNAL", "INTO", "IS", "JOIN", "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE", 
		"NEW", "NULL_", "OBJECT", "ON", "OPERATOR", "ORDERBY", "OUT", "OVERRIDE", 
		"PARAMS", "PARTIAL", "PRIVATE", "PROTECTED", "PUBLIC", "READONLY", "REF", 
		"REMOVE", "RETURN", "SBYTE", "SEALED", "SELECT", "SET", "SHORT", "SIZEOF", 
		"STACKALLOC", "STATIC", "STRING", "STRUCT", "SWITCH", "THIS", "THROW", 
		"TRUE", "TRY", "TYPEOF", "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE", 
		"USHORT", "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE", "WHEN", "WHERE", 
		"WHILE", "YIELD", "IDENTIFIER", "LITERAL_ACCESS", "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", 
		"BIN_INTEGER_LITERAL", "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING", 
		"VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START", "INTERPOLATED_VERBATIUM_STRING_START", 
		"OPEN_BRACE", "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS", 
		"CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON", "PLUS", "MINUS", 
		"STAR", "DIV", "PERCENT", "AMP", "BITWISE_OR", "CARET", "BANG", "TILDE", 
		"ASSIGNMENT", "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING", "OP_INC", 
		"OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ", "OP_NE", "OP_LE", "OP_GE", 
		"OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT", "OP_MULT_ASSIGNMENT", "OP_DIV_ASSIGNMENT", 
		"OP_MOD_ASSIGNMENT", "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", "OP_XOR_ASSIGNMENT", 
		"OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT", 
		"OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE", "REGULAR_CHAR_INSIDE", 
		"VERBATIUM_DOUBLE_QUOTE_INSIDE", "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", 
		"VERBATIUM_INSIDE_STRING", "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES", 
		"DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE", "ERROR", "WARNING", 
		"REGION", "ENDREGION", "PRAGMA", "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL", 
		"DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

	[NotNull]
	public override IVocabulary Vocabulary
	{
		get
		{
			return DefaultVocabulary;
		}
	}

	public override string GrammarFileName { get { return "CSharpPreprocessorParser.g4"; } }

	public override string[] RuleNames { get { return ruleNames; } }

	public override string SerializedAtn { get { return new string(_serializedATN); } }

	static CSharpPreprocessorParser() {
		decisionToDFA = new DFA[_ATN.NumberOfDecisions];
		for (int i = 0; i < _ATN.NumberOfDecisions; i++) {
			decisionToDFA[i] = new DFA(_ATN.GetDecisionState(i), i);
		}
	}

		public CSharpPreprocessorParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }

		public CSharpPreprocessorParser(ITokenStream input, TextWriter output, TextWriter errorOutput)
		: base(input, output, errorOutput)
	{
		Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
	}

	public partial class Preprocessor_directiveContext : ParserRuleContext {
		public Boolean value;
		public Preprocessor_directiveContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_preprocessor_directive; } }
	 
		public Preprocessor_directiveContext() { }
		public virtual void CopyFrom(Preprocessor_directiveContext context) {
			base.CopyFrom(context);
			this.value = context.value;
		}
	}
	public partial class PreprocessorDiagnosticContext : Preprocessor_directiveContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ERROR() { return GetToken(CSharpPreprocessorParser.ERROR, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TEXT() { return GetToken(CSharpPreprocessorParser.TEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WARNING() { return GetToken(CSharpPreprocessorParser.WARNING, 0); }
		public PreprocessorDiagnosticContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorDiagnostic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorDiagnostic(this);
		}
	}
	public partial class PreprocessorNullableContext : Preprocessor_directiveContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NULLABLE() { return GetToken(CSharpPreprocessorParser.NULLABLE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TEXT() { return GetToken(CSharpPreprocessorParser.TEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		public PreprocessorNullableContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorNullable(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorNullable(this);
		}
	}
	public partial class PreprocessorRegionContext : Preprocessor_directiveContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode REGION() { return GetToken(CSharpPreprocessorParser.REGION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TEXT() { return GetToken(CSharpPreprocessorParser.TEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENDREGION() { return GetToken(CSharpPreprocessorParser.ENDREGION, 0); }
		public PreprocessorRegionContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorRegion(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorRegion(this);
		}
	}
	public partial class PreprocessorDeclarationContext : Preprocessor_directiveContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEFINE() { return GetToken(CSharpPreprocessorParser.DEFINE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONDITIONAL_SYMBOL() { return GetToken(CSharpPreprocessorParser.CONDITIONAL_SYMBOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode UNDEF() { return GetToken(CSharpPreprocessorParser.UNDEF, 0); }
		public PreprocessorDeclarationContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorDeclaration(this);
		}
	}
	public partial class PreprocessorConditionalContext : Preprocessor_directiveContext {
		public Preprocessor_expressionContext expr;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IF() { return GetToken(CSharpPreprocessorParser.IF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public Preprocessor_expressionContext preprocessor_expression() {
			return GetRuleContext<Preprocessor_expressionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELIF() { return GetToken(CSharpPreprocessorParser.ELIF, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ELSE() { return GetToken(CSharpPreprocessorParser.ELSE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ENDIF() { return GetToken(CSharpPreprocessorParser.ENDIF, 0); }
		public PreprocessorConditionalContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorConditional(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorConditional(this);
		}
	}
	public partial class PreprocessorPragmaContext : Preprocessor_directiveContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode PRAGMA() { return GetToken(CSharpPreprocessorParser.PRAGMA, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TEXT() { return GetToken(CSharpPreprocessorParser.TEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		public PreprocessorPragmaContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorPragma(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorPragma(this);
		}
	}
	public partial class PreprocessorLineContext : Preprocessor_directiveContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LINE() { return GetToken(CSharpPreprocessorParser.LINE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
			return GetRuleContext<Directive_new_line_or_sharpContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIGITS() { return GetToken(CSharpPreprocessorParser.DIGITS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DEFAULT() { return GetToken(CSharpPreprocessorParser.DEFAULT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIRECTIVE_HIDDEN() { return GetToken(CSharpPreprocessorParser.DIRECTIVE_HIDDEN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(CSharpPreprocessorParser.STRING, 0); }
		public PreprocessorLineContext(Preprocessor_directiveContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessorLine(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessorLine(this);
		}
	}

	[RuleVersion(0)]
	public Preprocessor_directiveContext preprocessor_directive() {
		Preprocessor_directiveContext _localctx = new Preprocessor_directiveContext(Context, State);
		EnterRule(_localctx, 0, RULE_preprocessor_directive);
		int _la;
		try {
			State = 80;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case DEFINE:
				_localctx = new PreprocessorDeclarationContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 6;
				Match(DEFINE);
				State = 7;
				Match(CONDITIONAL_SYMBOL);
				State = 8;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveDefine(); 
				}
				break;
			case UNDEF:
				_localctx = new PreprocessorDeclarationContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 11;
				Match(UNDEF);
				State = 12;
				Match(CONDITIONAL_SYMBOL);
				State = 13;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveUndef(); 
				}
				break;
			case IF:
				_localctx = new PreprocessorConditionalContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 16;
				Match(IF);
				State = 17;
				((PreprocessorConditionalContext)_localctx).expr = preprocessor_expression(0);
				State = 18;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveIf(); 
						
				}
				break;
			case ELIF:
				_localctx = new PreprocessorConditionalContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 21;
				Match(ELIF);
				State = 22;
				((PreprocessorConditionalContext)_localctx).expr = preprocessor_expression(0);
				State = 23;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveElif(); 
						
				}
				break;
			case ELSE:
				_localctx = new PreprocessorConditionalContext(_localctx);
				EnterOuterAlt(_localctx, 5);
				{
				State = 26;
				Match(ELSE);
				State = 27;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveElse(); 
				}
				break;
			case ENDIF:
				_localctx = new PreprocessorConditionalContext(_localctx);
				EnterOuterAlt(_localctx, 6);
				{
				State = 30;
				Match(ENDIF);
				State = 31;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveEndif(); 
				}
				break;
			case LINE:
				_localctx = new PreprocessorLineContext(_localctx);
				EnterOuterAlt(_localctx, 7);
				{
				State = 34;
				Match(LINE);
				State = 41;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case DIGITS:
					{
					State = 35;
					Match(DIGITS);
					State = 37;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==STRING) {
						{
						State = 36;
						Match(STRING);
						}
					}

					}
					break;
				case DEFAULT:
					{
					State = 39;
					Match(DEFAULT);
					}
					break;
				case DIRECTIVE_HIDDEN:
					{
					State = 40;
					Match(DIRECTIVE_HIDDEN);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 43;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveLine(); 
						
				}
				break;
			case ERROR:
				_localctx = new PreprocessorDiagnosticContext(_localctx);
				EnterOuterAlt(_localctx, 8);
				{
				State = 46;
				Match(ERROR);
				State = 47;
				Match(TEXT);
				State = 48;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveError(); 
				}
				break;
			case WARNING:
				_localctx = new PreprocessorDiagnosticContext(_localctx);
				EnterOuterAlt(_localctx, 9);
				{
				State = 51;
				Match(WARNING);
				State = 52;
				Match(TEXT);
				State = 53;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveWarning(); 
				}
				break;
			case REGION:
				_localctx = new PreprocessorRegionContext(_localctx);
				EnterOuterAlt(_localctx, 10);
				{
				State = 56;
				Match(REGION);
				State = 58;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==TEXT) {
					{
					State = 57;
					Match(TEXT);
					}
				}

				State = 60;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveRegion(); 
				}
				break;
			case ENDREGION:
				_localctx = new PreprocessorRegionContext(_localctx);
				EnterOuterAlt(_localctx, 11);
				{
				State = 63;
				Match(ENDREGION);
				State = 65;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==TEXT) {
					{
					State = 64;
					Match(TEXT);
					}
				}

				State = 67;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveEndregion(); 
				}
				break;
			case PRAGMA:
				_localctx = new PreprocessorPragmaContext(_localctx);
				EnterOuterAlt(_localctx, 12);
				{
				State = 70;
				Match(PRAGMA);
				State = 71;
				Match(TEXT);
				State = 72;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectivePragma(); 
				}
				break;
			case NULLABLE:
				_localctx = new PreprocessorNullableContext(_localctx);
				EnterOuterAlt(_localctx, 13);
				{
				State = 75;
				Match(NULLABLE);
				State = 76;
				Match(TEXT);
				State = 77;
				directive_new_line_or_sharp();
				 this.OnPreprocessorDirectiveNullable(); 
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Directive_new_line_or_sharpContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIRECTIVE_NEW_LINE() { return GetToken(CSharpPreprocessorParser.DIRECTIVE_NEW_LINE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(CSharpPreprocessorParser.Eof, 0); }
		public Directive_new_line_or_sharpContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_directive_new_line_or_sharp; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterDirective_new_line_or_sharp(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitDirective_new_line_or_sharp(this);
		}
	}

	[RuleVersion(0)]
	public Directive_new_line_or_sharpContext directive_new_line_or_sharp() {
		Directive_new_line_or_sharpContext _localctx = new Directive_new_line_or_sharpContext(Context, State);
		EnterRule(_localctx, 2, RULE_directive_new_line_or_sharp);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 82;
			_la = TokenStream.LA(1);
			if ( !(_la==Eof || _la==DIRECTIVE_NEW_LINE) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class Preprocessor_expressionContext : ParserRuleContext {
		public String value;
		public Preprocessor_expressionContext expr1;
		public Preprocessor_expressionContext expr;
		public Preprocessor_expressionContext expr2;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TRUE() { return GetToken(CSharpPreprocessorParser.TRUE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FALSE() { return GetToken(CSharpPreprocessorParser.FALSE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CONDITIONAL_SYMBOL() { return GetToken(CSharpPreprocessorParser.CONDITIONAL_SYMBOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OPEN_PARENS() { return GetToken(CSharpPreprocessorParser.OPEN_PARENS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CLOSE_PARENS() { return GetToken(CSharpPreprocessorParser.CLOSE_PARENS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public Preprocessor_expressionContext[] preprocessor_expression() {
			return GetRuleContexts<Preprocessor_expressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public Preprocessor_expressionContext preprocessor_expression(int i) {
			return GetRuleContext<Preprocessor_expressionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BANG() { return GetToken(CSharpPreprocessorParser.BANG, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OP_EQ() { return GetToken(CSharpPreprocessorParser.OP_EQ, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OP_NE() { return GetToken(CSharpPreprocessorParser.OP_NE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OP_AND() { return GetToken(CSharpPreprocessorParser.OP_AND, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode OP_OR() { return GetToken(CSharpPreprocessorParser.OP_OR, 0); }
		public Preprocessor_expressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_preprocessor_expression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.EnterPreprocessor_expression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			ICSharpPreprocessorParserListener typedListener = listener as ICSharpPreprocessorParserListener;
			if (typedListener != null) typedListener.ExitPreprocessor_expression(this);
		}
	}

	[RuleVersion(0)]
	public Preprocessor_expressionContext preprocessor_expression() {
		return preprocessor_expression(0);
	}

	private Preprocessor_expressionContext preprocessor_expression(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		Preprocessor_expressionContext _localctx = new Preprocessor_expressionContext(Context, _parentState);
		Preprocessor_expressionContext _prevctx = _localctx;
		int _startState = 4;
		EnterRecursionRule(_localctx, 4, RULE_preprocessor_expression, _p);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 100;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case TRUE:
				{
				State = 85;
				Match(TRUE);
				 this.OnPreprocessorExpressionTrue(); 
				}
				break;
			case FALSE:
				{
				State = 87;
				Match(FALSE);
				 this.OnPreprocessorExpressionFalse(); 
				}
				break;
			case CONDITIONAL_SYMBOL:
				{
				State = 89;
				Match(CONDITIONAL_SYMBOL);
				 this.OnPreprocessorExpressionConditionalSymbol(); 
				}
				break;
			case OPEN_PARENS:
				{
				State = 91;
				Match(OPEN_PARENS);
				State = 92;
				_localctx.expr = preprocessor_expression(0);
				State = 93;
				Match(CLOSE_PARENS);
				 this.OnPreprocessorExpressionConditionalOpenParens(); 
						
				}
				break;
			case BANG:
				{
				State = 96;
				Match(BANG);
				State = 97;
				_localctx.expr = preprocessor_expression(5);
				 this.OnPreprocessorExpressionConditionalBang(); 
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			Context.Stop = TokenStream.LT(-1);
			State = 124;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,7,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 122;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) {
					case 1:
						{
						_localctx = new Preprocessor_expressionContext(_parentctx, _parentState);
						_localctx.expr1 = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
						State = 102;
						if (!(Precpred(Context, 4))) throw new FailedPredicateException(this, "Precpred(Context, 4)");
						State = 103;
						Match(OP_EQ);
						State = 104;
						_localctx.expr2 = preprocessor_expression(5);
						 this.OnPreprocessorExpressionConditionalEq(); 
						          		
						}
						break;
					case 2:
						{
						_localctx = new Preprocessor_expressionContext(_parentctx, _parentState);
						_localctx.expr1 = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
						State = 107;
						if (!(Precpred(Context, 3))) throw new FailedPredicateException(this, "Precpred(Context, 3)");
						State = 108;
						Match(OP_NE);
						State = 109;
						_localctx.expr2 = preprocessor_expression(4);
						 this.OnPreprocessorExpressionConditionalNe(); 
						          		
						}
						break;
					case 3:
						{
						_localctx = new Preprocessor_expressionContext(_parentctx, _parentState);
						_localctx.expr1 = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
						State = 112;
						if (!(Precpred(Context, 2))) throw new FailedPredicateException(this, "Precpred(Context, 2)");
						State = 113;
						Match(OP_AND);
						State = 114;
						_localctx.expr2 = preprocessor_expression(3);
						 this.OnPreprocessorExpressionConditionalAnd(); 
						          		
						}
						break;
					case 4:
						{
						_localctx = new Preprocessor_expressionContext(_parentctx, _parentState);
						_localctx.expr1 = _prevctx;
						PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
						State = 117;
						if (!(Precpred(Context, 1))) throw new FailedPredicateException(this, "Precpred(Context, 1)");
						State = 118;
						Match(OP_OR);
						State = 119;
						_localctx.expr2 = preprocessor_expression(2);
						 this.OnPreprocessorExpressionConditionalOr(); 
						          		
						}
						break;
					}
					} 
				}
				State = 126;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,7,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}

	public override bool Sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
		switch (ruleIndex) {
		case 2: return preprocessor_expression_sempred((Preprocessor_expressionContext)_localctx, predIndex);
		}
		return true;
	}
	private bool preprocessor_expression_sempred(Preprocessor_expressionContext _localctx, int predIndex) {
		switch (predIndex) {
		case 0: return Precpred(Context, 4);
		case 1: return Precpred(Context, 3);
		case 2: return Precpred(Context, 2);
		case 3: return Precpred(Context, 1);
		}
		return true;
	}

	private static char[] _serializedATN = {
		'\x3', '\x608B', '\xA72A', '\x8133', '\xB9ED', '\x417C', '\x3BE7', '\x7786', 
		'\x5964', '\x3', '\xC8', '\x82', '\x4', '\x2', '\t', '\x2', '\x4', '\x3', 
		'\t', '\x3', '\x4', '\x4', '\t', '\x4', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x5', '\x2', '(', '\n', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x5', '\x2', ',', '\n', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x5', 
		'\x2', '=', '\n', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', 
		'\x2', '\x3', '\x2', '\x5', '\x2', '\x44', '\n', '\x2', '\x3', '\x2', 
		'\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', 
		'\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', '\x3', '\x2', 
		'\x3', '\x2', '\x3', '\x2', '\x5', '\x2', 'S', '\n', '\x2', '\x3', '\x3', 
		'\x3', '\x3', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x5', '\x4', 'g', '\n', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', 
		'\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\x3', '\x4', '\a', '\x4', '}', 
		'\n', '\x4', '\f', '\x4', '\xE', '\x4', '\x80', '\v', '\x4', '\x3', '\x4', 
		'\x2', '\x3', '\x6', '\x5', '\x2', '\x4', '\x6', '\x2', '\x3', '\x3', 
		'\x3', '\xC6', '\xC6', '\x2', '\x97', '\x2', 'R', '\x3', '\x2', '\x2', 
		'\x2', '\x4', 'T', '\x3', '\x2', '\x2', '\x2', '\x6', '\x66', '\x3', '\x2', 
		'\x2', '\x2', '\b', '\t', '\a', '\xB9', '\x2', '\x2', '\t', '\n', '\a', 
		'\xC5', '\x2', '\x2', '\n', '\v', '\x5', '\x4', '\x3', '\x2', '\v', '\f', 
		'\b', '\x2', '\x1', '\x2', '\f', 'S', '\x3', '\x2', '\x2', '\x2', '\r', 
		'\xE', '\a', '\xBA', '\x2', '\x2', '\xE', '\xF', '\a', '\xC5', '\x2', 
		'\x2', '\xF', '\x10', '\x5', '\x4', '\x3', '\x2', '\x10', '\x11', '\b', 
		'\x2', '\x1', '\x2', '\x11', 'S', '\x3', '\x2', '\x2', '\x2', '\x12', 
		'\x13', '\a', '\x36', '\x2', '\x2', '\x13', '\x14', '\x5', '\x6', '\x4', 
		'\x2', '\x14', '\x15', '\x5', '\x4', '\x3', '\x2', '\x15', '\x16', '\b', 
		'\x2', '\x1', '\x2', '\x16', 'S', '\x3', '\x2', '\x2', '\x2', '\x17', 
		'\x18', '\a', '\xBB', '\x2', '\x2', '\x18', '\x19', '\x5', '\x6', '\x4', 
		'\x2', '\x19', '\x1A', '\x5', '\x4', '\x3', '\x2', '\x1A', '\x1B', '\b', 
		'\x2', '\x1', '\x2', '\x1B', 'S', '\x3', '\x2', '\x2', '\x2', '\x1C', 
		'\x1D', '\a', '&', '\x2', '\x2', '\x1D', '\x1E', '\x5', '\x4', '\x3', 
		'\x2', '\x1E', '\x1F', '\b', '\x2', '\x1', '\x2', '\x1F', 'S', '\x3', 
		'\x2', '\x2', '\x2', ' ', '!', '\a', '\xBC', '\x2', '\x2', '!', '\"', 
		'\x5', '\x4', '\x3', '\x2', '\"', '#', '\b', '\x2', '\x1', '\x2', '#', 
		'S', '\x3', '\x2', '\x2', '\x2', '$', '+', '\a', '\xBD', '\x2', '\x2', 
		'%', '\'', '\a', '\xB8', '\x2', '\x2', '&', '(', '\a', ']', '\x2', '\x2', 
		'\'', '&', '\x3', '\x2', '\x2', '\x2', '\'', '(', '\x3', '\x2', '\x2', 
		'\x2', '(', ',', '\x3', '\x2', '\x2', '\x2', ')', ',', '\a', ' ', '\x2', 
		'\x2', '*', ',', '\a', '\xC4', '\x2', '\x2', '+', '%', '\x3', '\x2', '\x2', 
		'\x2', '+', ')', '\x3', '\x2', '\x2', '\x2', '+', '*', '\x3', '\x2', '\x2', 
		'\x2', ',', '-', '\x3', '\x2', '\x2', '\x2', '-', '.', '\x5', '\x4', '\x3', 
		'\x2', '.', '/', '\b', '\x2', '\x1', '\x2', '/', 'S', '\x3', '\x2', '\x2', 
		'\x2', '\x30', '\x31', '\a', '\xBE', '\x2', '\x2', '\x31', '\x32', '\a', 
		'\xC7', '\x2', '\x2', '\x32', '\x33', '\x5', '\x4', '\x3', '\x2', '\x33', 
		'\x34', '\b', '\x2', '\x1', '\x2', '\x34', 'S', '\x3', '\x2', '\x2', '\x2', 
		'\x35', '\x36', '\a', '\xBF', '\x2', '\x2', '\x36', '\x37', '\a', '\xC7', 
		'\x2', '\x2', '\x37', '\x38', '\x5', '\x4', '\x3', '\x2', '\x38', '\x39', 
		'\b', '\x2', '\x1', '\x2', '\x39', 'S', '\x3', '\x2', '\x2', '\x2', ':', 
		'<', '\a', '\xC0', '\x2', '\x2', ';', '=', '\a', '\xC7', '\x2', '\x2', 
		'<', ';', '\x3', '\x2', '\x2', '\x2', '<', '=', '\x3', '\x2', '\x2', '\x2', 
		'=', '>', '\x3', '\x2', '\x2', '\x2', '>', '?', '\x5', '\x4', '\x3', '\x2', 
		'?', '@', '\b', '\x2', '\x1', '\x2', '@', 'S', '\x3', '\x2', '\x2', '\x2', 
		'\x41', '\x43', '\a', '\xC1', '\x2', '\x2', '\x42', '\x44', '\a', '\xC7', 
		'\x2', '\x2', '\x43', '\x42', '\x3', '\x2', '\x2', '\x2', '\x43', '\x44', 
		'\x3', '\x2', '\x2', '\x2', '\x44', '\x45', '\x3', '\x2', '\x2', '\x2', 
		'\x45', '\x46', '\x5', '\x4', '\x3', '\x2', '\x46', 'G', '\b', '\x2', 
		'\x1', '\x2', 'G', 'S', '\x3', '\x2', '\x2', '\x2', 'H', 'I', '\a', '\xC2', 
		'\x2', '\x2', 'I', 'J', '\a', '\xC7', '\x2', '\x2', 'J', 'K', '\x5', '\x4', 
		'\x3', '\x2', 'K', 'L', '\b', '\x2', '\x1', '\x2', 'L', 'S', '\x3', '\x2', 
		'\x2', '\x2', 'M', 'N', '\a', '\xC3', '\x2', '\x2', 'N', 'O', '\a', '\xC7', 
		'\x2', '\x2', 'O', 'P', '\x5', '\x4', '\x3', '\x2', 'P', 'Q', '\b', '\x2', 
		'\x1', '\x2', 'Q', 'S', '\x3', '\x2', '\x2', '\x2', 'R', '\b', '\x3', 
		'\x2', '\x2', '\x2', 'R', '\r', '\x3', '\x2', '\x2', '\x2', 'R', '\x12', 
		'\x3', '\x2', '\x2', '\x2', 'R', '\x17', '\x3', '\x2', '\x2', '\x2', 'R', 
		'\x1C', '\x3', '\x2', '\x2', '\x2', 'R', ' ', '\x3', '\x2', '\x2', '\x2', 
		'R', '$', '\x3', '\x2', '\x2', '\x2', 'R', '\x30', '\x3', '\x2', '\x2', 
		'\x2', 'R', '\x35', '\x3', '\x2', '\x2', '\x2', 'R', ':', '\x3', '\x2', 
		'\x2', '\x2', 'R', '\x41', '\x3', '\x2', '\x2', '\x2', 'R', 'H', '\x3', 
		'\x2', '\x2', '\x2', 'R', 'M', '\x3', '\x2', '\x2', '\x2', 'S', '\x3', 
		'\x3', '\x2', '\x2', '\x2', 'T', 'U', '\t', '\x2', '\x2', '\x2', 'U', 
		'\x5', '\x3', '\x2', '\x2', '\x2', 'V', 'W', '\b', '\x4', '\x1', '\x2', 
		'W', 'X', '\a', '\x62', '\x2', '\x2', 'X', 'g', '\b', '\x4', '\x1', '\x2', 
		'Y', 'Z', '\a', ',', '\x2', '\x2', 'Z', 'g', '\b', '\x4', '\x1', '\x2', 
		'[', '\\', '\a', '\xC5', '\x2', '\x2', '\\', 'g', '\b', '\x4', '\x1', 
		'\x2', ']', '^', '\a', '\x83', '\x2', '\x2', '^', '_', '\x5', '\x6', '\x4', 
		'\x2', '_', '`', '\a', '\x84', '\x2', '\x2', '`', '\x61', '\b', '\x4', 
		'\x1', '\x2', '\x61', 'g', '\x3', '\x2', '\x2', '\x2', '\x62', '\x63', 
		'\a', '\x91', '\x2', '\x2', '\x63', '\x64', '\x5', '\x6', '\x4', '\a', 
		'\x64', '\x65', '\b', '\x4', '\x1', '\x2', '\x65', 'g', '\x3', '\x2', 
		'\x2', '\x2', '\x66', 'V', '\x3', '\x2', '\x2', '\x2', '\x66', 'Y', '\x3', 
		'\x2', '\x2', '\x2', '\x66', '[', '\x3', '\x2', '\x2', '\x2', '\x66', 
		']', '\x3', '\x2', '\x2', '\x2', '\x66', '\x62', '\x3', '\x2', '\x2', 
		'\x2', 'g', '~', '\x3', '\x2', '\x2', '\x2', 'h', 'i', '\f', '\x6', '\x2', 
		'\x2', 'i', 'j', '\a', '\x9E', '\x2', '\x2', 'j', 'k', '\x5', '\x6', '\x4', 
		'\a', 'k', 'l', '\b', '\x4', '\x1', '\x2', 'l', '}', '\x3', '\x2', '\x2', 
		'\x2', 'm', 'n', '\f', '\x5', '\x2', '\x2', 'n', 'o', '\a', '\x9F', '\x2', 
		'\x2', 'o', 'p', '\x5', '\x6', '\x4', '\x6', 'p', 'q', '\b', '\x4', '\x1', 
		'\x2', 'q', '}', '\x3', '\x2', '\x2', '\x2', 'r', 's', '\f', '\x4', '\x2', 
		'\x2', 's', 't', '\a', '\x9B', '\x2', '\x2', 't', 'u', '\x5', '\x6', '\x4', 
		'\x5', 'u', 'v', '\b', '\x4', '\x1', '\x2', 'v', '}', '\x3', '\x2', '\x2', 
		'\x2', 'w', 'x', '\f', '\x3', '\x2', '\x2', 'x', 'y', '\a', '\x9C', '\x2', 
		'\x2', 'y', 'z', '\x5', '\x6', '\x4', '\x4', 'z', '{', '\b', '\x4', '\x1', 
		'\x2', '{', '}', '\x3', '\x2', '\x2', '\x2', '|', 'h', '\x3', '\x2', '\x2', 
		'\x2', '|', 'm', '\x3', '\x2', '\x2', '\x2', '|', 'r', '\x3', '\x2', '\x2', 
		'\x2', '|', 'w', '\x3', '\x2', '\x2', '\x2', '}', '\x80', '\x3', '\x2', 
		'\x2', '\x2', '~', '|', '\x3', '\x2', '\x2', '\x2', '~', '\x7F', '\x3', 
		'\x2', '\x2', '\x2', '\x7F', '\a', '\x3', '\x2', '\x2', '\x2', '\x80', 
		'~', '\x3', '\x2', '\x2', '\x2', '\n', '\'', '+', '<', '\x43', 'R', '\x66', 
		'|', '~',
	};

	public static readonly ATN _ATN =
		new ATNDeserializer().Deserialize(_serializedATN);


}