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

// Generated from E:/ProgettiUnity/InkAntlr/InkBlot/InkBlot/InkBlotAntlrGrammar.g4 by ANTLR 4.13.2

// 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.13.2")]
[System.CLSCompliant(false)]
public partial class InkBlotAntlrGrammarParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		T__0=1, T__1=2, T__2=3, T__3=4, THREAD_ARROW=5, DIVERT_ARROW=6, TUNNEL_ARROW=7, 
		IDENTIFIER=8, WS=9, NL=10;
	public const int
		RULE_story = 0, RULE_topLevelStatements = 1, RULE_topLevelStatement = 2, 
		RULE_multiDivert = 3, RULE_multiDivert_withoutWS = 4, RULE_multiDivertArrows_tail = 5, 
		RULE_divertIdentifierWithArguments = 6, RULE_divertIdentifierWithArguments_name = 7, 
		RULE_divertIdentifierWithArguments_arguments = 8, RULE_identifier = 9, 
		RULE_expression = 10;
	public static readonly string[] ruleNames = {
		"story", "topLevelStatements", "topLevelStatement", "multiDivert", "multiDivert_withoutWS", 
		"multiDivertArrows_tail", "divertIdentifierWithArguments", "divertIdentifierWithArguments_name", 
		"divertIdentifierWithArguments_arguments", "identifier", "expression"
	};

	private static readonly string[] _LiteralNames = {
		null, "'.'", "'('", "','", "')'", "'<-'", "'->'", "'->->'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, "THREAD_ARROW", "DIVERT_ARROW", "TUNNEL_ARROW", 
		"IDENTIFIER", "WS", "NL"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

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

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

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

	public override int[] SerializedAtn { get { return _serializedATN; } }

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

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

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

	public partial class StoryContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TopLevelStatementsContext topLevelStatements() {
			return GetRuleContext<TopLevelStatementsContext>(0);
		}
		public StoryContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_story; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterStory(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitStory(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStory(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StoryContext story() {
		StoryContext _localctx = new StoryContext(Context, State);
		EnterRule(_localctx, 0, RULE_story);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 22;
			topLevelStatements();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TopLevelStatementsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TopLevelStatementContext[] topLevelStatement() {
			return GetRuleContexts<TopLevelStatementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TopLevelStatementContext topLevelStatement(int i) {
			return GetRuleContext<TopLevelStatementContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] NL() { return GetTokens(InkBlotAntlrGrammarParser.NL); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NL(int i) {
			return GetToken(InkBlotAntlrGrammarParser.NL, i);
		}
		public TopLevelStatementsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_topLevelStatements; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterTopLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitTopLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTopLevelStatements(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TopLevelStatementsContext topLevelStatements() {
		TopLevelStatementsContext _localctx = new TopLevelStatementsContext(Context, State);
		EnterRule(_localctx, 2, RULE_topLevelStatements);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 24;
			topLevelStatement();
			State = 33;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,1,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 26;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					do {
						{
						{
						State = 25;
						Match(NL);
						}
						}
						State = 28;
						ErrorHandler.Sync(this);
						_la = TokenStream.LA(1);
					} while ( _la==NL );
					State = 30;
					topLevelStatement();
					}
					} 
				}
				State = 35;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,1,Context);
			}
			State = 39;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==NL) {
				{
				{
				State = 36;
				Match(NL);
				}
				}
				State = 41;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TopLevelStatementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert() {
			return GetRuleContext<MultiDivertContext>(0);
		}
		public TopLevelStatementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_topLevelStatement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterTopLevelStatement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitTopLevelStatement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTopLevelStatement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TopLevelStatementContext topLevelStatement() {
		TopLevelStatementContext _localctx = new TopLevelStatementContext(Context, State);
		EnterRule(_localctx, 4, RULE_topLevelStatement);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 42;
			multiDivert();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MultiDivertContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivert_withoutWSContext multiDivert_withoutWS() {
			return GetRuleContext<MultiDivert_withoutWSContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS() { return GetToken(InkBlotAntlrGrammarParser.WS, 0); }
		public MultiDivertContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_multiDivert; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivert(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivert(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivert(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MultiDivertContext multiDivert() {
		MultiDivertContext _localctx = new MultiDivertContext(Context, State);
		EnterRule(_localctx, 6, RULE_multiDivert);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 45;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 44;
				Match(WS);
				}
			}

			State = 47;
			multiDivert_withoutWS();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MultiDivert_withoutWSContext : ParserRuleContext {
		public MultiDivert_withoutWSContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_multiDivert_withoutWS; } }
	 
		public MultiDivert_withoutWSContext() { }
		public virtual void CopyFrom(MultiDivert_withoutWSContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class MultiDivertArrowsContext : MultiDivert_withoutWSContext {
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertArrows_tailContext multiDivertArrows_tail() {
			return GetRuleContext<MultiDivertArrows_tailContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] DIVERT_ARROW() { return GetTokens(InkBlotAntlrGrammarParser.DIVERT_ARROW); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIVERT_ARROW(int i) {
			return GetToken(InkBlotAntlrGrammarParser.DIVERT_ARROW, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext[] divertIdentifierWithArguments() {
			return GetRuleContexts<DivertIdentifierWithArgumentsContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments(int i) {
			return GetRuleContext<DivertIdentifierWithArgumentsContext>(i);
		}
		public MultiDivertArrowsContext(MultiDivert_withoutWSContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivertArrows(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivertArrows(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class MultiDivertThreadContext : MultiDivert_withoutWSContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode THREAD_ARROW() { return GetToken(InkBlotAntlrGrammarParser.THREAD_ARROW, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
			return GetRuleContext<DivertIdentifierWithArgumentsContext>(0);
		}
		public MultiDivertThreadContext(MultiDivert_withoutWSContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivertThread(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivertThread(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivertThread(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MultiDivert_withoutWSContext multiDivert_withoutWS() {
		MultiDivert_withoutWSContext _localctx = new MultiDivert_withoutWSContext(Context, State);
		EnterRule(_localctx, 8, RULE_multiDivert_withoutWS);
		try {
			int _alt;
			State = 59;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case THREAD_ARROW:
				_localctx = new MultiDivertThreadContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 49;
				Match(THREAD_ARROW);
				State = 50;
				divertIdentifierWithArguments();
				}
				break;
			case DIVERT_ARROW:
			case TUNNEL_ARROW:
				_localctx = new MultiDivertArrowsContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 55;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,4,Context);
				while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
					if ( _alt==1 ) {
						{
						{
						State = 51;
						Match(DIVERT_ARROW);
						State = 52;
						divertIdentifierWithArguments();
						}
						} 
					}
					State = 57;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,4,Context);
				}
				State = 58;
				multiDivertArrows_tail();
				}
				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 MultiDivertArrows_tailContext : ParserRuleContext {
		public MultiDivertArrows_tailContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_multiDivertArrows_tail; } }
	 
		public MultiDivertArrows_tailContext() { }
		public virtual void CopyFrom(MultiDivertArrows_tailContext context) {
			base.CopyFrom(context);
		}
	}
	public partial class MultiDivertArrows_tailTunnelWithReplacementContext : MultiDivertArrows_tailContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TUNNEL_ARROW() { return GetToken(InkBlotAntlrGrammarParser.TUNNEL_ARROW, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
			return GetRuleContext<DivertIdentifierWithArgumentsContext>(0);
		}
		public MultiDivertArrows_tailTunnelWithReplacementContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivertArrows_tailTunnelWithReplacement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivertArrows_tailTunnelWithReplacement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailTunnelWithReplacement(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class MultiDivertArrows_tailDivertContext : MultiDivertArrows_tailContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIVERT_ARROW() { return GetToken(InkBlotAntlrGrammarParser.DIVERT_ARROW, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
			return GetRuleContext<DivertIdentifierWithArgumentsContext>(0);
		}
		public MultiDivertArrows_tailDivertContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivertArrows_tailDivert(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivertArrows_tailDivert(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailDivert(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class MultiDivertArrows_tailTunnelContext : MultiDivertArrows_tailContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TUNNEL_ARROW() { return GetToken(InkBlotAntlrGrammarParser.TUNNEL_ARROW, 0); }
		public MultiDivertArrows_tailTunnelContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivertArrows_tailTunnel(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivertArrows_tailTunnel(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailTunnel(this);
			else return visitor.VisitChildren(this);
		}
	}
	public partial class MultiDivertArrows_tailDefaultChoiceContext : MultiDivertArrows_tailContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DIVERT_ARROW() { return GetToken(InkBlotAntlrGrammarParser.DIVERT_ARROW, 0); }
		public MultiDivertArrows_tailDefaultChoiceContext(MultiDivertArrows_tailContext context) { CopyFrom(context); }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMultiDivertArrows_tailDefaultChoice(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMultiDivertArrows_tailDefaultChoice(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMultiDivertArrows_tailDefaultChoice(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MultiDivertArrows_tailContext multiDivertArrows_tail() {
		MultiDivertArrows_tailContext _localctx = new MultiDivertArrows_tailContext(Context, State);
		EnterRule(_localctx, 10, RULE_multiDivertArrows_tail);
		try {
			State = 67;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,6,Context) ) {
			case 1:
				_localctx = new MultiDivertArrows_tailDivertContext(_localctx);
				EnterOuterAlt(_localctx, 1);
				{
				State = 61;
				Match(DIVERT_ARROW);
				State = 62;
				divertIdentifierWithArguments();
				}
				break;
			case 2:
				_localctx = new MultiDivertArrows_tailTunnelWithReplacementContext(_localctx);
				EnterOuterAlt(_localctx, 2);
				{
				State = 63;
				Match(TUNNEL_ARROW);
				State = 64;
				divertIdentifierWithArguments();
				}
				break;
			case 3:
				_localctx = new MultiDivertArrows_tailDefaultChoiceContext(_localctx);
				EnterOuterAlt(_localctx, 3);
				{
				State = 65;
				Match(DIVERT_ARROW);
				}
				break;
			case 4:
				_localctx = new MultiDivertArrows_tailTunnelContext(_localctx);
				EnterOuterAlt(_localctx, 4);
				{
				State = 66;
				Match(TUNNEL_ARROW);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DivertIdentifierWithArgumentsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArguments_nameContext divertIdentifierWithArguments_name() {
			return GetRuleContext<DivertIdentifierWithArguments_nameContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
			return GetToken(InkBlotAntlrGrammarParser.WS, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArguments_argumentsContext divertIdentifierWithArguments_arguments() {
			return GetRuleContext<DivertIdentifierWithArguments_argumentsContext>(0);
		}
		public DivertIdentifierWithArgumentsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_divertIdentifierWithArguments; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterDivertIdentifierWithArguments(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitDivertIdentifierWithArguments(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDivertIdentifierWithArguments(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments() {
		DivertIdentifierWithArgumentsContext _localctx = new DivertIdentifierWithArgumentsContext(Context, State);
		EnterRule(_localctx, 12, RULE_divertIdentifierWithArguments);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 70;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 69;
				Match(WS);
				}
			}

			State = 72;
			divertIdentifierWithArguments_name();
			State = 74;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,8,Context) ) {
			case 1:
				{
				State = 73;
				divertIdentifierWithArguments_arguments();
				}
				break;
			}
			State = 77;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 76;
				Match(WS);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DivertIdentifierWithArguments_nameContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierContext[] identifier() {
			return GetRuleContexts<IdentifierContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public IdentifierContext identifier(int i) {
			return GetRuleContext<IdentifierContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
			return GetToken(InkBlotAntlrGrammarParser.WS, i);
		}
		public DivertIdentifierWithArguments_nameContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_divertIdentifierWithArguments_name; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterDivertIdentifierWithArguments_name(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitDivertIdentifierWithArguments_name(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDivertIdentifierWithArguments_name(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DivertIdentifierWithArguments_nameContext divertIdentifierWithArguments_name() {
		DivertIdentifierWithArguments_nameContext _localctx = new DivertIdentifierWithArguments_nameContext(Context, State);
		EnterRule(_localctx, 14, RULE_divertIdentifierWithArguments_name);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 79;
			identifier();
			State = 90;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,12,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER ) {
				if ( _alt==1 ) {
					{
					{
					State = 81;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==WS) {
						{
						State = 80;
						Match(WS);
						}
					}

					State = 83;
					Match(T__0);
					State = 85;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==WS) {
						{
						State = 84;
						Match(WS);
						}
					}

					State = 87;
					identifier();
					}
					} 
				}
				State = 92;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,12,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DivertIdentifierWithArguments_argumentsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
			return GetToken(InkBlotAntlrGrammarParser.WS, i);
		}
		public DivertIdentifierWithArguments_argumentsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_divertIdentifierWithArguments_arguments; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterDivertIdentifierWithArguments_arguments(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitDivertIdentifierWithArguments_arguments(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDivertIdentifierWithArguments_arguments(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DivertIdentifierWithArguments_argumentsContext divertIdentifierWithArguments_arguments() {
		DivertIdentifierWithArguments_argumentsContext _localctx = new DivertIdentifierWithArguments_argumentsContext(Context, State);
		EnterRule(_localctx, 16, RULE_divertIdentifierWithArguments_arguments);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 94;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 93;
				Match(WS);
				}
			}

			State = 96;
			Match(T__1);
			State = 97;
			expression();
			State = 105;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__2) {
				{
				{
				State = 98;
				Match(T__2);
				State = 100;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==WS) {
					{
					State = 99;
					Match(WS);
					}
				}

				State = 102;
				expression();
				}
				}
				State = 107;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 108;
			Match(T__3);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class IdentifierContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(InkBlotAntlrGrammarParser.IDENTIFIER, 0); }
		public IdentifierContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_identifier; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterIdentifier(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitIdentifier(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitIdentifier(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public IdentifierContext identifier() {
		IdentifierContext _localctx = new IdentifierContext(Context, State);
		EnterRule(_localctx, 18, RULE_identifier);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 110;
			Match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ExpressionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(InkBlotAntlrGrammarParser.IDENTIFIER, 0); }
		public ExpressionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_expression; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitExpression(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitExpression(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ExpressionContext expression() {
		ExpressionContext _localctx = new ExpressionContext(Context, State);
		EnterRule(_localctx, 20, RULE_expression);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 112;
			Match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	private static int[] _serializedATN = {
		4,1,10,115,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
		7,7,2,8,7,8,2,9,7,9,2,10,7,10,1,0,1,0,1,1,1,1,4,1,27,8,1,11,1,12,1,28,
		1,1,5,1,32,8,1,10,1,12,1,35,9,1,1,1,5,1,38,8,1,10,1,12,1,41,9,1,1,2,1,
		2,1,3,3,3,46,8,3,1,3,1,3,1,4,1,4,1,4,1,4,5,4,54,8,4,10,4,12,4,57,9,4,1,
		4,3,4,60,8,4,1,5,1,5,1,5,1,5,1,5,1,5,3,5,68,8,5,1,6,3,6,71,8,6,1,6,1,6,
		3,6,75,8,6,1,6,3,6,78,8,6,1,7,1,7,3,7,82,8,7,1,7,1,7,3,7,86,8,7,1,7,5,
		7,89,8,7,10,7,12,7,92,9,7,1,8,3,8,95,8,8,1,8,1,8,1,8,1,8,3,8,101,8,8,1,
		8,5,8,104,8,8,10,8,12,8,107,9,8,1,8,1,8,1,9,1,9,1,10,1,10,1,10,0,0,11,
		0,2,4,6,8,10,12,14,16,18,20,0,0,121,0,22,1,0,0,0,2,24,1,0,0,0,4,42,1,0,
		0,0,6,45,1,0,0,0,8,59,1,0,0,0,10,67,1,0,0,0,12,70,1,0,0,0,14,79,1,0,0,
		0,16,94,1,0,0,0,18,110,1,0,0,0,20,112,1,0,0,0,22,23,3,2,1,0,23,1,1,0,0,
		0,24,33,3,4,2,0,25,27,5,10,0,0,26,25,1,0,0,0,27,28,1,0,0,0,28,26,1,0,0,
		0,28,29,1,0,0,0,29,30,1,0,0,0,30,32,3,4,2,0,31,26,1,0,0,0,32,35,1,0,0,
		0,33,31,1,0,0,0,33,34,1,0,0,0,34,39,1,0,0,0,35,33,1,0,0,0,36,38,5,10,0,
		0,37,36,1,0,0,0,38,41,1,0,0,0,39,37,1,0,0,0,39,40,1,0,0,0,40,3,1,0,0,0,
		41,39,1,0,0,0,42,43,3,6,3,0,43,5,1,0,0,0,44,46,5,9,0,0,45,44,1,0,0,0,45,
		46,1,0,0,0,46,47,1,0,0,0,47,48,3,8,4,0,48,7,1,0,0,0,49,50,5,5,0,0,50,60,
		3,12,6,0,51,52,5,6,0,0,52,54,3,12,6,0,53,51,1,0,0,0,54,57,1,0,0,0,55,53,
		1,0,0,0,55,56,1,0,0,0,56,58,1,0,0,0,57,55,1,0,0,0,58,60,3,10,5,0,59,49,
		1,0,0,0,59,55,1,0,0,0,60,9,1,0,0,0,61,62,5,6,0,0,62,68,3,12,6,0,63,64,
		5,7,0,0,64,68,3,12,6,0,65,68,5,6,0,0,66,68,5,7,0,0,67,61,1,0,0,0,67,63,
		1,0,0,0,67,65,1,0,0,0,67,66,1,0,0,0,68,11,1,0,0,0,69,71,5,9,0,0,70,69,
		1,0,0,0,70,71,1,0,0,0,71,72,1,0,0,0,72,74,3,14,7,0,73,75,3,16,8,0,74,73,
		1,0,0,0,74,75,1,0,0,0,75,77,1,0,0,0,76,78,5,9,0,0,77,76,1,0,0,0,77,78,
		1,0,0,0,78,13,1,0,0,0,79,90,3,18,9,0,80,82,5,9,0,0,81,80,1,0,0,0,81,82,
		1,0,0,0,82,83,1,0,0,0,83,85,5,1,0,0,84,86,5,9,0,0,85,84,1,0,0,0,85,86,
		1,0,0,0,86,87,1,0,0,0,87,89,3,18,9,0,88,81,1,0,0,0,89,92,1,0,0,0,90,88,
		1,0,0,0,90,91,1,0,0,0,91,15,1,0,0,0,92,90,1,0,0,0,93,95,5,9,0,0,94,93,
		1,0,0,0,94,95,1,0,0,0,95,96,1,0,0,0,96,97,5,2,0,0,97,105,3,20,10,0,98,
		100,5,3,0,0,99,101,5,9,0,0,100,99,1,0,0,0,100,101,1,0,0,0,101,102,1,0,
		0,0,102,104,3,20,10,0,103,98,1,0,0,0,104,107,1,0,0,0,105,103,1,0,0,0,105,
		106,1,0,0,0,106,108,1,0,0,0,107,105,1,0,0,0,108,109,5,4,0,0,109,17,1,0,
		0,0,110,111,5,8,0,0,111,19,1,0,0,0,112,113,5,8,0,0,113,21,1,0,0,0,16,28,
		33,39,45,55,59,67,70,74,77,81,85,90,94,100,105
	};

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


}