//------------------------------------------------------------------------------
// <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, T__4=5, T__5=6, WS=7, NL=8, MULTILINE_WS=9, 
		CONTENT_TEXT_NO_ESCAPE_SIMPLE=10, INLINE_LOGIC_START=11, INLINE_LOGIC_END=12, 
		SEQUENCE_TYPE_SYMBOL_ANNOTATION=13, ONCE=14, CYCLE=15, SHUFFLE=16, STOPPING=17, 
		SHUFFLE_ONCE=18, SHUFFLE_STOPPING=19, THREAD_ARROW=20, DIVERT_ARROW=21, 
		TUNNEL_ARROW=22, IDENTIFIER=23;
	public const int
		RULE_story = 0, RULE_topLevelStatements = 1, RULE_topLevelStatement = 2, 
		RULE_knotLevelStatements = 3, RULE_stitchLevelStatements = 4, RULE_innerBlockLevelStatements = 5, 
		RULE_contentText = 6, RULE_mixedTextAndLogic = 7, RULE_inlineLogicOrGlueOrTagStart = 8, 
		RULE_inlineLogic = 9, RULE_innerLogic = 10, RULE_multiDivert = 11, RULE_divertIdentifierWithArguments = 12, 
		RULE_identifier = 13, RULE_expression = 14, RULE_sequenceTypeAnnotation = 15, 
		RULE_innerSequenceObjects = 16, RULE_innerMultilineSequenceObjects = 17, 
		RULE_singleMultilineSequenceElement = 18, RULE_innerInlineSequenceObjects = 19;
	public static readonly string[] ruleNames = {
		"story", "topLevelStatements", "topLevelStatement", "knotLevelStatements", 
		"stitchLevelStatements", "innerBlockLevelStatements", "contentText", "mixedTextAndLogic", 
		"inlineLogicOrGlueOrTagStart", "inlineLogic", "innerLogic", "multiDivert", 
		"divertIdentifierWithArguments", "identifier", "expression", "sequenceTypeAnnotation", 
		"innerSequenceObjects", "innerMultilineSequenceObjects", "singleMultilineSequenceElement", 
		"innerInlineSequenceObjects"
	};

	private static readonly string[] _LiteralNames = {
		null, "'.'", "'('", "','", "')'", "'-'", "'|'", null, null, null, null, 
		"'{'", "'}'", null, null, null, null, null, null, null, "'<-'", "'->'", 
		"'->->'"
	};
	private static readonly string[] _SymbolicNames = {
		null, null, null, null, null, null, null, "WS", "NL", "MULTILINE_WS", 
		"CONTENT_TEXT_NO_ESCAPE_SIMPLE", "INLINE_LOGIC_START", "INLINE_LOGIC_END", 
		"SEQUENCE_TYPE_SYMBOL_ANNOTATION", "ONCE", "CYCLE", "SHUFFLE", "STOPPING", 
		"SHUFFLE_ONCE", "SHUFFLE_STOPPING", "THREAD_ARROW", "DIVERT_ARROW", "TUNNEL_ARROW", 
		"IDENTIFIER"
	};
	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 = 40;
			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);
		}
		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 {
			EnterOuterAlt(_localctx, 1);
			{
			State = 43;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 42;
				topLevelStatement();
				}
				}
				State = 45;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 7341184L) != 0) );
			}
		}
		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 ContentTextContext contentText() {
			return GetRuleContext<ContentTextContext>(0);
		}
		[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 {
			State = 49;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
				EnterOuterAlt(_localctx, 1);
				{
				State = 47;
				contentText();
				}
				break;
			case WS:
			case THREAD_ARROW:
			case DIVERT_ARROW:
			case TUNNEL_ARROW:
				EnterOuterAlt(_localctx, 2);
				{
				State = 48;
				multiDivert();
				}
				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 KnotLevelStatementsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
			return GetRuleContexts<ContentTextContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
			return GetRuleContext<ContentTextContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext[] multiDivert() {
			return GetRuleContexts<MultiDivertContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert(int i) {
			return GetRuleContext<MultiDivertContext>(i);
		}
		public KnotLevelStatementsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_knotLevelStatements; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterKnotLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitKnotLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitKnotLevelStatements(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public KnotLevelStatementsContext knotLevelStatements() {
		KnotLevelStatementsContext _localctx = new KnotLevelStatementsContext(Context, State);
		EnterRule(_localctx, 6, RULE_knotLevelStatements);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 53;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				State = 53;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
					{
					State = 51;
					contentText();
					}
					break;
				case WS:
				case THREAD_ARROW:
				case DIVERT_ARROW:
				case TUNNEL_ARROW:
					{
					State = 52;
					multiDivert();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 55;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 7341184L) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StitchLevelStatementsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
			return GetRuleContexts<ContentTextContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
			return GetRuleContext<ContentTextContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext[] multiDivert() {
			return GetRuleContexts<MultiDivertContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert(int i) {
			return GetRuleContext<MultiDivertContext>(i);
		}
		public StitchLevelStatementsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_stitchLevelStatements; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterStitchLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitStitchLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStitchLevelStatements(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StitchLevelStatementsContext stitchLevelStatements() {
		StitchLevelStatementsContext _localctx = new StitchLevelStatementsContext(Context, State);
		EnterRule(_localctx, 8, RULE_stitchLevelStatements);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 59;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				State = 59;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
					{
					State = 57;
					contentText();
					}
					break;
				case WS:
				case THREAD_ARROW:
				case DIVERT_ARROW:
				case TUNNEL_ARROW:
					{
					State = 58;
					multiDivert();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 61;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 7341184L) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InnerBlockLevelStatementsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
			return GetRuleContexts<ContentTextContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
			return GetRuleContext<ContentTextContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext[] multiDivert() {
			return GetRuleContexts<MultiDivertContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert(int i) {
			return GetRuleContext<MultiDivertContext>(i);
		}
		public InnerBlockLevelStatementsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_innerBlockLevelStatements; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInnerBlockLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInnerBlockLevelStatements(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInnerBlockLevelStatements(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InnerBlockLevelStatementsContext innerBlockLevelStatements() {
		InnerBlockLevelStatementsContext _localctx = new InnerBlockLevelStatementsContext(Context, State);
		EnterRule(_localctx, 10, RULE_innerBlockLevelStatements);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 65;
			ErrorHandler.Sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					State = 65;
					ErrorHandler.Sync(this);
					switch (TokenStream.LA(1)) {
					case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
						{
						State = 63;
						contentText();
						}
						break;
					case WS:
					case THREAD_ARROW:
					case DIVERT_ARROW:
					case TUNNEL_ARROW:
						{
						State = 64;
						multiDivert();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 67;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,7,Context);
			} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

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

	[RuleVersion(0)]
	public ContentTextContext contentText() {
		ContentTextContext _localctx = new ContentTextContext(Context, State);
		EnterRule(_localctx, 12, RULE_contentText);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 69;
			Match(CONTENT_TEXT_NO_ESCAPE_SIMPLE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class MixedTextAndLogicContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MultiDivertContext multiDivert() {
			return GetRuleContext<MultiDivertContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext[] contentText() {
			return GetRuleContexts<ContentTextContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ContentTextContext contentText(int i) {
			return GetRuleContext<ContentTextContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InlineLogicOrGlueOrTagStartContext[] inlineLogicOrGlueOrTagStart() {
			return GetRuleContexts<InlineLogicOrGlueOrTagStartContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public InlineLogicOrGlueOrTagStartContext inlineLogicOrGlueOrTagStart(int i) {
			return GetRuleContext<InlineLogicOrGlueOrTagStartContext>(i);
		}
		public MixedTextAndLogicContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_mixedTextAndLogic; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterMixedTextAndLogic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitMixedTextAndLogic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitMixedTextAndLogic(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public MixedTextAndLogicContext mixedTextAndLogic() {
		MixedTextAndLogicContext _localctx = new MixedTextAndLogicContext(Context, State);
		EnterRule(_localctx, 14, RULE_mixedTextAndLogic);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 72;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,8,Context) ) {
			case 1:
				{
				State = 71;
				contentText();
				}
				break;
			}
			State = 82;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				State = 82;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,11,Context) ) {
				case 1:
					{
					State = 75;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==INLINE_LOGIC_START) {
						{
						State = 74;
						inlineLogicOrGlueOrTagStart();
						}
					}

					State = 77;
					contentText();
					}
					break;
				case 2:
					{
					State = 78;
					inlineLogicOrGlueOrTagStart();
					State = 80;
					ErrorHandler.Sync(this);
					switch ( Interpreter.AdaptivePredict(TokenStream,10,Context) ) {
					case 1:
						{
						State = 79;
						contentText();
						}
						break;
					}
					}
					break;
				}
				}
				State = 84;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( _la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START );
			State = 86;
			multiDivert();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InlineLogicOrGlueOrTagStartContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public InlineLogicContext inlineLogic() {
			return GetRuleContext<InlineLogicContext>(0);
		}
		public InlineLogicOrGlueOrTagStartContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_inlineLogicOrGlueOrTagStart; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInlineLogicOrGlueOrTagStart(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInlineLogicOrGlueOrTagStart(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInlineLogicOrGlueOrTagStart(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InlineLogicOrGlueOrTagStartContext inlineLogicOrGlueOrTagStart() {
		InlineLogicOrGlueOrTagStartContext _localctx = new InlineLogicOrGlueOrTagStartContext(Context, State);
		EnterRule(_localctx, 16, RULE_inlineLogicOrGlueOrTagStart);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 88;
			inlineLogic();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InlineLogicContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INLINE_LOGIC_START() { return GetToken(InkBlotAntlrGrammarParser.INLINE_LOGIC_START, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public InnerLogicContext innerLogic() {
			return GetRuleContext<InnerLogicContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INLINE_LOGIC_END() { return GetToken(InkBlotAntlrGrammarParser.INLINE_LOGIC_END, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
			return GetToken(InkBlotAntlrGrammarParser.WS, i);
		}
		public InlineLogicContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_inlineLogic; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInlineLogic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInlineLogic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInlineLogic(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InlineLogicContext inlineLogic() {
		InlineLogicContext _localctx = new InlineLogicContext(Context, State);
		EnterRule(_localctx, 18, RULE_inlineLogic);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 90;
			Match(INLINE_LOGIC_START);
			State = 92;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) {
			case 1:
				{
				State = 91;
				Match(WS);
				}
				break;
			}
			State = 94;
			innerLogic();
			State = 96;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 95;
				Match(WS);
				}
			}

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

	public partial class InnerLogicContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SequenceTypeAnnotationContext sequenceTypeAnnotation() {
			return GetRuleContext<SequenceTypeAnnotationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InnerSequenceObjectsContext innerSequenceObjects() {
			return GetRuleContext<InnerSequenceObjectsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS() { return GetToken(InkBlotAntlrGrammarParser.WS, 0); }
		public InnerLogicContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_innerLogic; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInnerLogic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInnerLogic(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInnerLogic(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InnerLogicContext innerLogic() {
		InnerLogicContext _localctx = new InnerLogicContext(Context, State);
		EnterRule(_localctx, 20, RULE_innerLogic);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 101;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 100;
				Match(WS);
				}
			}

			State = 103;
			sequenceTypeAnnotation();
			State = 104;
			innerSequenceObjects();
			}
		}
		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 ITerminalNode THREAD_ARROW() { return GetToken(InkBlotAntlrGrammarParser.THREAD_ARROW, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext[] divertIdentifierWithArguments() {
			return GetRuleContexts<DivertIdentifierWithArgumentsContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public DivertIdentifierWithArgumentsContext divertIdentifierWithArguments(int i) {
			return GetRuleContext<DivertIdentifierWithArgumentsContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode TUNNEL_ARROW() { return GetToken(InkBlotAntlrGrammarParser.TUNNEL_ARROW, 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 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, 22, RULE_multiDivert);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 107;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 106;
				Match(WS);
				}
			}

			State = 138;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,20,Context) ) {
			case 1:
				{
				State = 109;
				Match(THREAD_ARROW);
				State = 110;
				divertIdentifierWithArguments();
				}
				break;
			case 2:
				{
				State = 113;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				do {
					{
					{
					State = 111;
					Match(DIVERT_ARROW);
					State = 112;
					divertIdentifierWithArguments();
					}
					}
					State = 115;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				} while ( _la==DIVERT_ARROW );
				State = 117;
				Match(TUNNEL_ARROW);
				State = 118;
				divertIdentifierWithArguments();
				}
				break;
			case 3:
				{
				State = 122;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				do {
					{
					{
					State = 120;
					Match(DIVERT_ARROW);
					State = 121;
					divertIdentifierWithArguments();
					}
					}
					State = 124;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				} while ( _la==DIVERT_ARROW );
				State = 126;
				Match(TUNNEL_ARROW);
				}
				break;
			case 4:
				{
				State = 130;
				ErrorHandler.Sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						State = 128;
						Match(DIVERT_ARROW);
						State = 129;
						divertIdentifierWithArguments();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					State = 132;
					ErrorHandler.Sync(this);
					_alt = Interpreter.AdaptivePredict(TokenStream,19,Context);
				} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
				State = 134;
				Match(DIVERT_ARROW);
				}
				break;
			case 5:
				{
				State = 136;
				Match(TUNNEL_ARROW);
				}
				break;
			case 6:
				{
				State = 137;
				Match(DIVERT_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 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);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext[] expression() {
			return GetRuleContexts<ExpressionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ExpressionContext expression(int i) {
			return GetRuleContext<ExpressionContext>(i);
		}
		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, 24, RULE_divertIdentifierWithArguments);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 141;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 140;
				Match(WS);
				}
			}

			State = 143;
			identifier();
			State = 145;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,22,Context) ) {
			case 1:
				{
				State = 144;
				Match(WS);
				}
				break;
			}
			State = 157;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==T__0) {
				{
				{
				State = 147;
				Match(T__0);
				State = 149;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				if (_la==WS) {
					{
					State = 148;
					Match(WS);
					}
				}

				State = 151;
				identifier();
				State = 153;
				ErrorHandler.Sync(this);
				switch ( Interpreter.AdaptivePredict(TokenStream,24,Context) ) {
				case 1:
					{
					State = 152;
					Match(WS);
					}
					break;
				}
				}
				}
				State = 159;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 161;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,26,Context) ) {
			case 1:
				{
				State = 160;
				Match(WS);
				}
				break;
			}
			State = 174;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==T__1) {
				{
				State = 163;
				Match(T__1);
				State = 164;
				expression();
				State = 169;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__2) {
					{
					{
					State = 165;
					Match(T__2);
					State = 166;
					expression();
					}
					}
					State = 171;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				State = 172;
				Match(T__3);
				}
			}

			State = 177;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,29,Context) ) {
			case 1:
				{
				State = 176;
				Match(WS);
				}
				break;
			}
			}
		}
		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, 26, RULE_identifier);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 179;
			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, 28, RULE_expression);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 181;
			Match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SequenceTypeAnnotationContext : ParserRuleContext {
		public IToken op;
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEQUENCE_TYPE_SYMBOL_ANNOTATION() { return GetToken(InkBlotAntlrGrammarParser.SEQUENCE_TYPE_SYMBOL_ANNOTATION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ONCE() { return GetToken(InkBlotAntlrGrammarParser.ONCE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode CYCLE() { return GetToken(InkBlotAntlrGrammarParser.CYCLE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHUFFLE() { return GetToken(InkBlotAntlrGrammarParser.SHUFFLE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STOPPING() { return GetToken(InkBlotAntlrGrammarParser.STOPPING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHUFFLE_ONCE() { return GetToken(InkBlotAntlrGrammarParser.SHUFFLE_ONCE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SHUFFLE_STOPPING() { return GetToken(InkBlotAntlrGrammarParser.SHUFFLE_STOPPING, 0); }
		public SequenceTypeAnnotationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_sequenceTypeAnnotation; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterSequenceTypeAnnotation(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitSequenceTypeAnnotation(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSequenceTypeAnnotation(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SequenceTypeAnnotationContext sequenceTypeAnnotation() {
		SequenceTypeAnnotationContext _localctx = new SequenceTypeAnnotationContext(Context, State);
		EnterRule(_localctx, 30, RULE_sequenceTypeAnnotation);
		try {
			State = 190;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case SEQUENCE_TYPE_SYMBOL_ANNOTATION:
				EnterOuterAlt(_localctx, 1);
				{
				State = 183;
				_localctx.op = Match(SEQUENCE_TYPE_SYMBOL_ANNOTATION);
				}
				break;
			case ONCE:
				EnterOuterAlt(_localctx, 2);
				{
				State = 184;
				Match(ONCE);
				}
				break;
			case CYCLE:
				EnterOuterAlt(_localctx, 3);
				{
				State = 185;
				Match(CYCLE);
				}
				break;
			case SHUFFLE:
				EnterOuterAlt(_localctx, 4);
				{
				State = 186;
				Match(SHUFFLE);
				}
				break;
			case STOPPING:
				EnterOuterAlt(_localctx, 5);
				{
				State = 187;
				Match(STOPPING);
				}
				break;
			case SHUFFLE_ONCE:
				EnterOuterAlt(_localctx, 6);
				{
				State = 188;
				Match(SHUFFLE_ONCE);
				}
				break;
			case SHUFFLE_STOPPING:
				EnterOuterAlt(_localctx, 7);
				{
				State = 189;
				Match(SHUFFLE_STOPPING);
				}
				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 InnerSequenceObjectsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode NL() { return GetToken(InkBlotAntlrGrammarParser.NL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public InnerMultilineSequenceObjectsContext innerMultilineSequenceObjects() {
			return GetRuleContext<InnerMultilineSequenceObjectsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public InnerInlineSequenceObjectsContext innerInlineSequenceObjects() {
			return GetRuleContext<InnerInlineSequenceObjectsContext>(0);
		}
		public InnerSequenceObjectsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_innerSequenceObjects; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInnerSequenceObjects(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInnerSequenceObjects(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInnerSequenceObjects(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InnerSequenceObjectsContext innerSequenceObjects() {
		InnerSequenceObjectsContext _localctx = new InnerSequenceObjectsContext(Context, State);
		EnterRule(_localctx, 32, RULE_innerSequenceObjects);
		try {
			State = 195;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case NL:
				EnterOuterAlt(_localctx, 1);
				{
				State = 192;
				Match(NL);
				State = 193;
				innerMultilineSequenceObjects();
				}
				break;
			case T__5:
			case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
			case INLINE_LOGIC_START:
				EnterOuterAlt(_localctx, 2);
				{
				State = 194;
				innerInlineSequenceObjects();
				}
				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 InnerMultilineSequenceObjectsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public SingleMultilineSequenceElementContext[] singleMultilineSequenceElement() {
			return GetRuleContexts<SingleMultilineSequenceElementContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public SingleMultilineSequenceElementContext singleMultilineSequenceElement(int i) {
			return GetRuleContext<SingleMultilineSequenceElementContext>(i);
		}
		public InnerMultilineSequenceObjectsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_innerMultilineSequenceObjects; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInnerMultilineSequenceObjects(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInnerMultilineSequenceObjects(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInnerMultilineSequenceObjects(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InnerMultilineSequenceObjectsContext innerMultilineSequenceObjects() {
		InnerMultilineSequenceObjectsContext _localctx = new InnerMultilineSequenceObjectsContext(Context, State);
		EnterRule(_localctx, 34, RULE_innerMultilineSequenceObjects);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 198;
			ErrorHandler.Sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					State = 197;
					singleMultilineSequenceElement();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 200;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,32,Context);
			} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SingleMultilineSequenceElementContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public InnerBlockLevelStatementsContext innerBlockLevelStatements() {
			return GetRuleContext<InnerBlockLevelStatementsContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MULTILINE_WS() { return GetToken(InkBlotAntlrGrammarParser.MULTILINE_WS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] WS() { return GetTokens(InkBlotAntlrGrammarParser.WS); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode WS(int i) {
			return GetToken(InkBlotAntlrGrammarParser.WS, i);
		}
		public SingleMultilineSequenceElementContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_singleMultilineSequenceElement; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterSingleMultilineSequenceElement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitSingleMultilineSequenceElement(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSingleMultilineSequenceElement(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SingleMultilineSequenceElementContext singleMultilineSequenceElement() {
		SingleMultilineSequenceElementContext _localctx = new SingleMultilineSequenceElementContext(Context, State);
		EnterRule(_localctx, 36, RULE_singleMultilineSequenceElement);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 203;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==WS) {
				{
				State = 202;
				Match(WS);
				}
			}

			State = 205;
			Match(T__4);
			State = 207;
			ErrorHandler.Sync(this);
			switch ( Interpreter.AdaptivePredict(TokenStream,34,Context) ) {
			case 1:
				{
				State = 206;
				Match(WS);
				}
				break;
			}
			State = 211;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case WS:
			case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
			case THREAD_ARROW:
			case DIVERT_ARROW:
			case TUNNEL_ARROW:
				{
				State = 209;
				innerBlockLevelStatements();
				}
				break;
			case MULTILINE_WS:
				{
				State = 210;
				Match(MULTILINE_WS);
				}
				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 InnerInlineSequenceObjectsContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public MixedTextAndLogicContext[] mixedTextAndLogic() {
			return GetRuleContexts<MixedTextAndLogicContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public MixedTextAndLogicContext mixedTextAndLogic(int i) {
			return GetRuleContext<MixedTextAndLogicContext>(i);
		}
		public InnerInlineSequenceObjectsContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_innerInlineSequenceObjects; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.EnterInnerInlineSequenceObjects(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IInkBlotAntlrGrammarListener typedListener = listener as IInkBlotAntlrGrammarListener;
			if (typedListener != null) typedListener.ExitInnerInlineSequenceObjects(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IInkBlotAntlrGrammarVisitor<TResult> typedVisitor = visitor as IInkBlotAntlrGrammarVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInnerInlineSequenceObjects(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InnerInlineSequenceObjectsContext innerInlineSequenceObjects() {
		InnerInlineSequenceObjectsContext _localctx = new InnerInlineSequenceObjectsContext(Context, State);
		EnterRule(_localctx, 38, RULE_innerInlineSequenceObjects);
		int _la;
		try {
			State = 231;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case CONTENT_TEXT_NO_ESCAPE_SIMPLE:
			case INLINE_LOGIC_START:
				EnterOuterAlt(_localctx, 1);
				{
				{
				State = 213;
				mixedTextAndLogic();
				State = 220;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				while (_la==T__5) {
					{
					{
					State = 214;
					Match(T__5);
					State = 216;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START) {
						{
						State = 215;
						mixedTextAndLogic();
						}
					}

					}
					}
					State = 222;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				}
				}
				}
				break;
			case T__5:
				EnterOuterAlt(_localctx, 2);
				{
				State = 227;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
				do {
					{
					{
					State = 223;
					Match(T__5);
					State = 225;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
					if (_la==CONTENT_TEXT_NO_ESCAPE_SIMPLE || _la==INLINE_LOGIC_START) {
						{
						State = 224;
						mixedTextAndLogic();
						}
					}

					}
					}
					State = 229;
					ErrorHandler.Sync(this);
					_la = TokenStream.LA(1);
				} while ( _la==T__5 );
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	private static int[] _serializedATN = {
		4,1,23,234,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
		7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,7,14,
		2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,1,0,1,0,1,1,4,1,44,8,
		1,11,1,12,1,45,1,2,1,2,3,2,50,8,2,1,3,1,3,4,3,54,8,3,11,3,12,3,55,1,4,
		1,4,4,4,60,8,4,11,4,12,4,61,1,5,1,5,4,5,66,8,5,11,5,12,5,67,1,6,1,6,1,
		7,3,7,73,8,7,1,7,3,7,76,8,7,1,7,1,7,1,7,3,7,81,8,7,4,7,83,8,7,11,7,12,
		7,84,1,7,1,7,1,8,1,8,1,9,1,9,3,9,93,8,9,1,9,1,9,3,9,97,8,9,1,9,1,9,1,10,
		3,10,102,8,10,1,10,1,10,1,10,1,11,3,11,108,8,11,1,11,1,11,1,11,1,11,4,
		11,114,8,11,11,11,12,11,115,1,11,1,11,1,11,1,11,1,11,4,11,123,8,11,11,
		11,12,11,124,1,11,1,11,1,11,1,11,4,11,131,8,11,11,11,12,11,132,1,11,1,
		11,1,11,1,11,3,11,139,8,11,1,12,3,12,142,8,12,1,12,1,12,3,12,146,8,12,
		1,12,1,12,3,12,150,8,12,1,12,1,12,3,12,154,8,12,5,12,156,8,12,10,12,12,
		12,159,9,12,1,12,3,12,162,8,12,1,12,1,12,1,12,1,12,5,12,168,8,12,10,12,
		12,12,171,9,12,1,12,1,12,3,12,175,8,12,1,12,3,12,178,8,12,1,13,1,13,1,
		14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,191,8,15,1,16,1,16,1,16,
		3,16,196,8,16,1,17,4,17,199,8,17,11,17,12,17,200,1,18,3,18,204,8,18,1,
		18,1,18,3,18,208,8,18,1,18,1,18,3,18,212,8,18,1,19,1,19,1,19,3,19,217,
		8,19,5,19,219,8,19,10,19,12,19,222,9,19,1,19,1,19,3,19,226,8,19,4,19,228,
		8,19,11,19,12,19,229,3,19,232,8,19,1,19,0,0,20,0,2,4,6,8,10,12,14,16,18,
		20,22,24,26,28,30,32,34,36,38,0,0,263,0,40,1,0,0,0,2,43,1,0,0,0,4,49,1,
		0,0,0,6,53,1,0,0,0,8,59,1,0,0,0,10,65,1,0,0,0,12,69,1,0,0,0,14,72,1,0,
		0,0,16,88,1,0,0,0,18,90,1,0,0,0,20,101,1,0,0,0,22,107,1,0,0,0,24,141,1,
		0,0,0,26,179,1,0,0,0,28,181,1,0,0,0,30,190,1,0,0,0,32,195,1,0,0,0,34,198,
		1,0,0,0,36,203,1,0,0,0,38,231,1,0,0,0,40,41,3,2,1,0,41,1,1,0,0,0,42,44,
		3,4,2,0,43,42,1,0,0,0,44,45,1,0,0,0,45,43,1,0,0,0,45,46,1,0,0,0,46,3,1,
		0,0,0,47,50,3,12,6,0,48,50,3,22,11,0,49,47,1,0,0,0,49,48,1,0,0,0,50,5,
		1,0,0,0,51,54,3,12,6,0,52,54,3,22,11,0,53,51,1,0,0,0,53,52,1,0,0,0,54,
		55,1,0,0,0,55,53,1,0,0,0,55,56,1,0,0,0,56,7,1,0,0,0,57,60,3,12,6,0,58,
		60,3,22,11,0,59,57,1,0,0,0,59,58,1,0,0,0,60,61,1,0,0,0,61,59,1,0,0,0,61,
		62,1,0,0,0,62,9,1,0,0,0,63,66,3,12,6,0,64,66,3,22,11,0,65,63,1,0,0,0,65,
		64,1,0,0,0,66,67,1,0,0,0,67,65,1,0,0,0,67,68,1,0,0,0,68,11,1,0,0,0,69,
		70,5,10,0,0,70,13,1,0,0,0,71,73,3,12,6,0,72,71,1,0,0,0,72,73,1,0,0,0,73,
		82,1,0,0,0,74,76,3,16,8,0,75,74,1,0,0,0,75,76,1,0,0,0,76,77,1,0,0,0,77,
		83,3,12,6,0,78,80,3,16,8,0,79,81,3,12,6,0,80,79,1,0,0,0,80,81,1,0,0,0,
		81,83,1,0,0,0,82,75,1,0,0,0,82,78,1,0,0,0,83,84,1,0,0,0,84,82,1,0,0,0,
		84,85,1,0,0,0,85,86,1,0,0,0,86,87,3,22,11,0,87,15,1,0,0,0,88,89,3,18,9,
		0,89,17,1,0,0,0,90,92,5,11,0,0,91,93,5,7,0,0,92,91,1,0,0,0,92,93,1,0,0,
		0,93,94,1,0,0,0,94,96,3,20,10,0,95,97,5,7,0,0,96,95,1,0,0,0,96,97,1,0,
		0,0,97,98,1,0,0,0,98,99,5,12,0,0,99,19,1,0,0,0,100,102,5,7,0,0,101,100,
		1,0,0,0,101,102,1,0,0,0,102,103,1,0,0,0,103,104,3,30,15,0,104,105,3,32,
		16,0,105,21,1,0,0,0,106,108,5,7,0,0,107,106,1,0,0,0,107,108,1,0,0,0,108,
		138,1,0,0,0,109,110,5,20,0,0,110,139,3,24,12,0,111,112,5,21,0,0,112,114,
		3,24,12,0,113,111,1,0,0,0,114,115,1,0,0,0,115,113,1,0,0,0,115,116,1,0,
		0,0,116,117,1,0,0,0,117,118,5,22,0,0,118,119,3,24,12,0,119,139,1,0,0,0,
		120,121,5,21,0,0,121,123,3,24,12,0,122,120,1,0,0,0,123,124,1,0,0,0,124,
		122,1,0,0,0,124,125,1,0,0,0,125,126,1,0,0,0,126,127,5,22,0,0,127,139,1,
		0,0,0,128,129,5,21,0,0,129,131,3,24,12,0,130,128,1,0,0,0,131,132,1,0,0,
		0,132,130,1,0,0,0,132,133,1,0,0,0,133,134,1,0,0,0,134,135,5,21,0,0,135,
		139,1,0,0,0,136,139,5,22,0,0,137,139,5,21,0,0,138,109,1,0,0,0,138,113,
		1,0,0,0,138,122,1,0,0,0,138,130,1,0,0,0,138,136,1,0,0,0,138,137,1,0,0,
		0,139,23,1,0,0,0,140,142,5,7,0,0,141,140,1,0,0,0,141,142,1,0,0,0,142,143,
		1,0,0,0,143,145,3,26,13,0,144,146,5,7,0,0,145,144,1,0,0,0,145,146,1,0,
		0,0,146,157,1,0,0,0,147,149,5,1,0,0,148,150,5,7,0,0,149,148,1,0,0,0,149,
		150,1,0,0,0,150,151,1,0,0,0,151,153,3,26,13,0,152,154,5,7,0,0,153,152,
		1,0,0,0,153,154,1,0,0,0,154,156,1,0,0,0,155,147,1,0,0,0,156,159,1,0,0,
		0,157,155,1,0,0,0,157,158,1,0,0,0,158,161,1,0,0,0,159,157,1,0,0,0,160,
		162,5,7,0,0,161,160,1,0,0,0,161,162,1,0,0,0,162,174,1,0,0,0,163,164,5,
		2,0,0,164,169,3,28,14,0,165,166,5,3,0,0,166,168,3,28,14,0,167,165,1,0,
		0,0,168,171,1,0,0,0,169,167,1,0,0,0,169,170,1,0,0,0,170,172,1,0,0,0,171,
		169,1,0,0,0,172,173,5,4,0,0,173,175,1,0,0,0,174,163,1,0,0,0,174,175,1,
		0,0,0,175,177,1,0,0,0,176,178,5,7,0,0,177,176,1,0,0,0,177,178,1,0,0,0,
		178,25,1,0,0,0,179,180,5,23,0,0,180,27,1,0,0,0,181,182,5,23,0,0,182,29,
		1,0,0,0,183,191,5,13,0,0,184,191,5,14,0,0,185,191,5,15,0,0,186,191,5,16,
		0,0,187,191,5,17,0,0,188,191,5,18,0,0,189,191,5,19,0,0,190,183,1,0,0,0,
		190,184,1,0,0,0,190,185,1,0,0,0,190,186,1,0,0,0,190,187,1,0,0,0,190,188,
		1,0,0,0,190,189,1,0,0,0,191,31,1,0,0,0,192,193,5,8,0,0,193,196,3,34,17,
		0,194,196,3,38,19,0,195,192,1,0,0,0,195,194,1,0,0,0,196,33,1,0,0,0,197,
		199,3,36,18,0,198,197,1,0,0,0,199,200,1,0,0,0,200,198,1,0,0,0,200,201,
		1,0,0,0,201,35,1,0,0,0,202,204,5,7,0,0,203,202,1,0,0,0,203,204,1,0,0,0,
		204,205,1,0,0,0,205,207,5,5,0,0,206,208,5,7,0,0,207,206,1,0,0,0,207,208,
		1,0,0,0,208,211,1,0,0,0,209,212,3,10,5,0,210,212,5,9,0,0,211,209,1,0,0,
		0,211,210,1,0,0,0,212,37,1,0,0,0,213,220,3,14,7,0,214,216,5,6,0,0,215,
		217,3,14,7,0,216,215,1,0,0,0,216,217,1,0,0,0,217,219,1,0,0,0,218,214,1,
		0,0,0,219,222,1,0,0,0,220,218,1,0,0,0,220,221,1,0,0,0,221,232,1,0,0,0,
		222,220,1,0,0,0,223,225,5,6,0,0,224,226,3,14,7,0,225,224,1,0,0,0,225,226,
		1,0,0,0,226,228,1,0,0,0,227,223,1,0,0,0,228,229,1,0,0,0,229,227,1,0,0,
		0,229,230,1,0,0,0,230,232,1,0,0,0,231,213,1,0,0,0,231,227,1,0,0,0,232,
		39,1,0,0,0,41,45,49,53,55,59,61,65,67,72,75,80,82,84,92,96,101,107,115,
		124,132,138,141,145,149,153,157,161,169,174,177,190,195,200,203,207,211,
		216,220,225,229,231
	};

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


}