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

// Generated from /Users/niwa_kazutomo/Dropbox/develop/gs2/gs2-sdk/unity/Assets/Scripts/Runtime/Sdk/Gs2/Unity/Gs2StateMachine/Local/Laxer/StateMachineParser.g4 by ANTLR 4.13.1

// 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

namespace Gs2.Unity.Gs2StateMachine.Local.Parser {
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.1")]
[System.CLSCompliant(false)]
public partial class StateMachineParser : Parser {
	protected static DFA[] decisionToDFA;
	protected static PredictionContextCache sharedContextCache = new PredictionContextCache();
	public const int
		KW_STATEMACHINE=1, KW_PARAMETERS=2, KW_VARIABLES=3, KW_ENTRYPOINT=4, KW_TASK=5, 
		KW_SUBSTATEMACHINETASK=6, KW_PASSTASK=7, KW_ERRORTASK=8, KW_WAITTASK=9, 
		KW_EVENT=10, KW_IN=11, KW_OUT=12, KW_USING=13, KW_HANDLING=14, KW_SCRIPT=15, 
		KW_PAYLOAD_LBRACE=16, KW_TRANSITION=17, INT=18, FLOAT=19, STRING=20, BOOL=21, 
		ARRAY=22, MAP=23, LBRACE=24, RBRACE=25, LPAREN=26, RPAREN=27, SEMI=28, 
		COMMA=29, ARROW=30, DARROW=31, IDENTIFIER=32, GRN=33, WS=34, COMMENT=35, 
		RAW_SCRIPT_LBRACE=36, RAW_SCRIPT_RBRACE=37, RAW_SCRIPT_TEXT=38;
	public const int
		RULE_stateMachines = 0, RULE_stateMachineDeclaration = 1, RULE_stateMachineBody = 2, 
		RULE_parametersSection = 3, RULE_parameterDeclaration = 4, RULE_variablesSection = 5, 
		RULE_variableDeclaration = 6, RULE_entryPointSection = 7, RULE_tasksSection = 8, 
		RULE_transitionsSection = 9, RULE_dataType = 10, RULE_parameterList = 11, 
		RULE_parameter = 12, RULE_taskDeclaration = 13, RULE_subStateMachineTaskDeclaration = 14, 
		RULE_passTaskDeclaration = 15, RULE_errorTaskDeclaration = 16, RULE_waitTaskDeclaration = 17, 
		RULE_subStateMachineTaskBody = 18, RULE_taskBody = 19, RULE_waitTaskBody = 20, 
		RULE_eventDeclarationSection = 21, RULE_inParametersSection = 22, RULE_inParameterMapping = 23, 
		RULE_outParametersSection = 24, RULE_outParameterMapping = 25, RULE_usingStateMachineSection = 26, 
		RULE_scriptSection = 27, RULE_rawScriptSection = 28, RULE_rawScriptBody = 29, 
		RULE_transitionDeclaration = 30;
	public static readonly string[] ruleNames = {
		"stateMachines", "stateMachineDeclaration", "stateMachineBody", "parametersSection", 
		"parameterDeclaration", "variablesSection", "variableDeclaration", "entryPointSection", 
		"tasksSection", "transitionsSection", "dataType", "parameterList", "parameter", 
		"taskDeclaration", "subStateMachineTaskDeclaration", "passTaskDeclaration", 
		"errorTaskDeclaration", "waitTaskDeclaration", "subStateMachineTaskBody", 
		"taskBody", "waitTaskBody", "eventDeclarationSection", "inParametersSection", 
		"inParameterMapping", "outParametersSection", "outParameterMapping", "usingStateMachineSection", 
		"scriptSection", "rawScriptSection", "rawScriptBody", "transitionDeclaration"
	};

	private static readonly string[] _LiteralNames = {
		null, "'StateMachine'", "'Parameters'", "'Variables'", "'EntryPoint'", 
		"'Task'", "'SubStateMachineTask'", "'PassTask'", "'ErrorTask'", "'WaitTask'", 
		"'Event'", "'in'", "'out'", "'using'", "'handling'", "'Script'", null, 
		"'Transition'", "'int'", "'float'", "'string'", "'bool'", "'array'", "'map'", 
		null, null, "'('", "')'", "';'", "','", "'->'", "'<-'"
	};
	private static readonly string[] _SymbolicNames = {
		null, "KW_STATEMACHINE", "KW_PARAMETERS", "KW_VARIABLES", "KW_ENTRYPOINT", 
		"KW_TASK", "KW_SUBSTATEMACHINETASK", "KW_PASSTASK", "KW_ERRORTASK", "KW_WAITTASK", 
		"KW_EVENT", "KW_IN", "KW_OUT", "KW_USING", "KW_HANDLING", "KW_SCRIPT", 
		"KW_PAYLOAD_LBRACE", "KW_TRANSITION", "INT", "FLOAT", "STRING", "BOOL", 
		"ARRAY", "MAP", "LBRACE", "RBRACE", "LPAREN", "RPAREN", "SEMI", "COMMA", 
		"ARROW", "DARROW", "IDENTIFIER", "GRN", "WS", "COMMENT", "RAW_SCRIPT_LBRACE", 
		"RAW_SCRIPT_RBRACE", "RAW_SCRIPT_TEXT"
	};
	public static readonly IVocabulary DefaultVocabulary = new Vocabulary(_LiteralNames, _SymbolicNames);

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

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

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

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

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

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

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

	public partial class StateMachinesContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode Eof() { return GetToken(StateMachineParser.Eof, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public StateMachineDeclarationContext[] stateMachineDeclaration() {
			return GetRuleContexts<StateMachineDeclarationContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public StateMachineDeclarationContext stateMachineDeclaration(int i) {
			return GetRuleContext<StateMachineDeclarationContext>(i);
		}
		public StateMachinesContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_stateMachines; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterStateMachines(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitStateMachines(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStateMachines(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StateMachinesContext stateMachines() {
		StateMachinesContext _localctx = new StateMachinesContext(Context, State);
		EnterRule(_localctx, 0, RULE_stateMachines);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 63;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			do {
				{
				{
				State = 62;
				stateMachineDeclaration();
				}
				}
				State = 65;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			} while ( _la==KW_STATEMACHINE );
			State = 67;
			Match(Eof);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StateMachineDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_STATEMACHINE() { return GetToken(StateMachineParser.KW_STATEMACHINE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(StateMachineParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public StateMachineBodyContext stateMachineBody() {
			return GetRuleContext<StateMachineBodyContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(StateMachineParser.RBRACE, 0); }
		public StateMachineDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_stateMachineDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterStateMachineDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitStateMachineDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStateMachineDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StateMachineDeclarationContext stateMachineDeclaration() {
		StateMachineDeclarationContext _localctx = new StateMachineDeclarationContext(Context, State);
		EnterRule(_localctx, 2, RULE_stateMachineDeclaration);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 69;
			Match(KW_STATEMACHINE);
			State = 70;
			Match(IDENTIFIER);
			State = 71;
			Match(LBRACE);
			State = 72;
			stateMachineBody();
			State = 73;
			Match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class StateMachineBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public EntryPointSectionContext entryPointSection() {
			return GetRuleContext<EntryPointSectionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ParametersSectionContext parametersSection() {
			return GetRuleContext<ParametersSectionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public VariablesSectionContext variablesSection() {
			return GetRuleContext<VariablesSectionContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TasksSectionContext[] tasksSection() {
			return GetRuleContexts<TasksSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TasksSectionContext tasksSection(int i) {
			return GetRuleContext<TasksSectionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public TransitionsSectionContext[] transitionsSection() {
			return GetRuleContexts<TransitionsSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public TransitionsSectionContext transitionsSection(int i) {
			return GetRuleContext<TransitionsSectionContext>(i);
		}
		public StateMachineBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_stateMachineBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterStateMachineBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitStateMachineBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitStateMachineBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public StateMachineBodyContext stateMachineBody() {
		StateMachineBodyContext _localctx = new StateMachineBodyContext(Context, State);
		EnterRule(_localctx, 4, RULE_stateMachineBody);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 76;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==KW_PARAMETERS) {
				{
				State = 75;
				parametersSection();
				}
			}

			State = 79;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if (_la==KW_VARIABLES) {
				{
				State = 78;
				variablesSection();
				}
			}

			State = 81;
			entryPointSection();
			State = 85;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 992L) != 0)) {
				{
				{
				State = 82;
				tasksSection();
				}
				}
				State = 87;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 91;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==KW_TRANSITION) {
				{
				{
				State = 88;
				transitionsSection();
				}
				}
				State = 93;
				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 ParametersSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_PARAMETERS() { return GetToken(StateMachineParser.KW_PARAMETERS, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(StateMachineParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(StateMachineParser.RBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ParameterDeclarationContext[] parameterDeclaration() {
			return GetRuleContexts<ParameterDeclarationContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ParameterDeclarationContext parameterDeclaration(int i) {
			return GetRuleContext<ParameterDeclarationContext>(i);
		}
		public ParametersSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_parametersSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterParametersSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitParametersSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParametersSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ParametersSectionContext parametersSection() {
		ParametersSectionContext _localctx = new ParametersSectionContext(Context, State);
		EnterRule(_localctx, 6, RULE_parametersSection);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 94;
			Match(KW_PARAMETERS);
			State = 95;
			Match(LBRACE);
			State = 99;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 16515072L) != 0)) {
				{
				{
				State = 96;
				parameterDeclaration();
				}
				}
				State = 101;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 102;
			Match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ParameterDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		public ParameterDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_parameterDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterParameterDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitParameterDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParameterDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ParameterDeclarationContext parameterDeclaration() {
		ParameterDeclarationContext _localctx = new ParameterDeclarationContext(Context, State);
		EnterRule(_localctx, 8, RULE_parameterDeclaration);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 104;
			dataType();
			State = 105;
			Match(IDENTIFIER);
			State = 106;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VariablesSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_VARIABLES() { return GetToken(StateMachineParser.KW_VARIABLES, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(StateMachineParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(StateMachineParser.RBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public VariableDeclarationContext[] variableDeclaration() {
			return GetRuleContexts<VariableDeclarationContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public VariableDeclarationContext variableDeclaration(int i) {
			return GetRuleContext<VariableDeclarationContext>(i);
		}
		public VariablesSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variablesSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterVariablesSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitVariablesSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariablesSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VariablesSectionContext variablesSection() {
		VariablesSectionContext _localctx = new VariablesSectionContext(Context, State);
		EnterRule(_localctx, 10, RULE_variablesSection);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 108;
			Match(KW_VARIABLES);
			State = 109;
			Match(LBRACE);
			State = 113;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 16515072L) != 0)) {
				{
				{
				State = 110;
				variableDeclaration();
				}
				}
				State = 115;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 116;
			Match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class VariableDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(StateMachineParser.IDENTIFIER); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) {
			return GetToken(StateMachineParser.IDENTIFIER, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(StateMachineParser.COMMA); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) {
			return GetToken(StateMachineParser.COMMA, i);
		}
		public VariableDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_variableDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterVariableDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitVariableDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitVariableDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public VariableDeclarationContext variableDeclaration() {
		VariableDeclarationContext _localctx = new VariableDeclarationContext(Context, State);
		EnterRule(_localctx, 12, RULE_variableDeclaration);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 118;
			dataType();
			State = 119;
			Match(IDENTIFIER);
			State = 124;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMA) {
				{
				{
				State = 120;
				Match(COMMA);
				State = 121;
				Match(IDENTIFIER);
				}
				}
				State = 126;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 127;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class EntryPointSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_ENTRYPOINT() { return GetToken(StateMachineParser.KW_ENTRYPOINT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		public EntryPointSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_entryPointSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterEntryPointSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitEntryPointSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEntryPointSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EntryPointSectionContext entryPointSection() {
		EntryPointSectionContext _localctx = new EntryPointSectionContext(Context, State);
		EnterRule(_localctx, 14, RULE_entryPointSection);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 129;
			Match(KW_ENTRYPOINT);
			State = 130;
			Match(IDENTIFIER);
			State = 131;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TasksSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TaskDeclarationContext taskDeclaration() {
			return GetRuleContext<TaskDeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public SubStateMachineTaskDeclarationContext subStateMachineTaskDeclaration() {
			return GetRuleContext<SubStateMachineTaskDeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public PassTaskDeclarationContext passTaskDeclaration() {
			return GetRuleContext<PassTaskDeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ErrorTaskDeclarationContext errorTaskDeclaration() {
			return GetRuleContext<ErrorTaskDeclarationContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public WaitTaskDeclarationContext waitTaskDeclaration() {
			return GetRuleContext<WaitTaskDeclarationContext>(0);
		}
		public TasksSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_tasksSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterTasksSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitTasksSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTasksSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TasksSectionContext tasksSection() {
		TasksSectionContext _localctx = new TasksSectionContext(Context, State);
		EnterRule(_localctx, 16, RULE_tasksSection);
		try {
			State = 138;
			ErrorHandler.Sync(this);
			switch (TokenStream.LA(1)) {
			case KW_TASK:
				EnterOuterAlt(_localctx, 1);
				{
				State = 133;
				taskDeclaration();
				}
				break;
			case KW_SUBSTATEMACHINETASK:
				EnterOuterAlt(_localctx, 2);
				{
				State = 134;
				subStateMachineTaskDeclaration();
				}
				break;
			case KW_PASSTASK:
				EnterOuterAlt(_localctx, 3);
				{
				State = 135;
				passTaskDeclaration();
				}
				break;
			case KW_ERRORTASK:
				EnterOuterAlt(_localctx, 4);
				{
				State = 136;
				errorTaskDeclaration();
				}
				break;
			case KW_WAITTASK:
				EnterOuterAlt(_localctx, 5);
				{
				State = 137;
				waitTaskDeclaration();
				}
				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 TransitionsSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public TransitionDeclarationContext transitionDeclaration() {
			return GetRuleContext<TransitionDeclarationContext>(0);
		}
		public TransitionsSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_transitionsSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterTransitionsSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitTransitionsSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTransitionsSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TransitionsSectionContext transitionsSection() {
		TransitionsSectionContext _localctx = new TransitionsSectionContext(Context, State);
		EnterRule(_localctx, 18, RULE_transitionsSection);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 140;
			transitionDeclaration();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class DataTypeContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode INT() { return GetToken(StateMachineParser.INT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode FLOAT() { return GetToken(StateMachineParser.FLOAT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode STRING() { return GetToken(StateMachineParser.STRING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode BOOL() { return GetToken(StateMachineParser.BOOL, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARRAY() { return GetToken(StateMachineParser.ARRAY, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode MAP() { return GetToken(StateMachineParser.MAP, 0); }
		public DataTypeContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_dataType; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterDataType(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitDataType(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitDataType(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public DataTypeContext dataType() {
		DataTypeContext _localctx = new DataTypeContext(Context, State);
		EnterRule(_localctx, 20, RULE_dataType);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 142;
			_la = TokenStream.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 16515072L) != 0)) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ParameterListContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ParameterContext[] parameter() {
			return GetRuleContexts<ParameterContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ParameterContext parameter(int i) {
			return GetRuleContext<ParameterContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(StateMachineParser.COMMA); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) {
			return GetToken(StateMachineParser.COMMA, i);
		}
		public ParameterListContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_parameterList; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterParameterList(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitParameterList(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParameterList(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ParameterListContext parameterList() {
		ParameterListContext _localctx = new ParameterListContext(Context, State);
		EnterRule(_localctx, 22, RULE_parameterList);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 144;
			parameter();
			State = 149;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMA) {
				{
				{
				State = 145;
				Match(COMMA);
				State = 146;
				parameter();
				}
				}
				State = 151;
				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 ParameterContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public DataTypeContext dataType() {
			return GetRuleContext<DataTypeContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		public ParameterContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_parameter; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterParameter(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitParameter(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitParameter(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ParameterContext parameter() {
		ParameterContext _localctx = new ParameterContext(Context, State);
		EnterRule(_localctx, 24, RULE_parameter);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 152;
			dataType();
			State = 153;
			Match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TaskDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_TASK() { return GetToken(StateMachineParser.KW_TASK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(StateMachineParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(StateMachineParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(StateMachineParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public TaskBodyContext taskBody() {
			return GetRuleContext<TaskBodyContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(StateMachineParser.RBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ParameterListContext parameterList() {
			return GetRuleContext<ParameterListContext>(0);
		}
		public TaskDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_taskDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTaskDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TaskDeclarationContext taskDeclaration() {
		TaskDeclarationContext _localctx = new TaskDeclarationContext(Context, State);
		EnterRule(_localctx, 26, RULE_taskDeclaration);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 155;
			Match(KW_TASK);
			State = 156;
			Match(IDENTIFIER);
			State = 157;
			Match(LPAREN);
			State = 159;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 16515072L) != 0)) {
				{
				State = 158;
				parameterList();
				}
			}

			State = 161;
			Match(RPAREN);
			State = 162;
			Match(LBRACE);
			State = 163;
			taskBody();
			State = 164;
			Match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SubStateMachineTaskDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_SUBSTATEMACHINETASK() { return GetToken(StateMachineParser.KW_SUBSTATEMACHINETASK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(StateMachineParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public SubStateMachineTaskBodyContext subStateMachineTaskBody() {
			return GetRuleContext<SubStateMachineTaskBodyContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(StateMachineParser.RBRACE, 0); }
		public SubStateMachineTaskDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_subStateMachineTaskDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterSubStateMachineTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitSubStateMachineTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSubStateMachineTaskDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SubStateMachineTaskDeclarationContext subStateMachineTaskDeclaration() {
		SubStateMachineTaskDeclarationContext _localctx = new SubStateMachineTaskDeclarationContext(Context, State);
		EnterRule(_localctx, 28, RULE_subStateMachineTaskDeclaration);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 166;
			Match(KW_SUBSTATEMACHINETASK);
			State = 167;
			Match(IDENTIFIER);
			State = 168;
			Match(LBRACE);
			State = 169;
			subStateMachineTaskBody();
			State = 170;
			Match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class PassTaskDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_PASSTASK() { return GetToken(StateMachineParser.KW_PASSTASK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		public PassTaskDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_passTaskDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterPassTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitPassTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitPassTaskDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public PassTaskDeclarationContext passTaskDeclaration() {
		PassTaskDeclarationContext _localctx = new PassTaskDeclarationContext(Context, State);
		EnterRule(_localctx, 30, RULE_passTaskDeclaration);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 172;
			Match(KW_PASSTASK);
			State = 173;
			Match(IDENTIFIER);
			State = 174;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ErrorTaskDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_ERRORTASK() { return GetToken(StateMachineParser.KW_ERRORTASK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(StateMachineParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(StateMachineParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ParameterListContext parameterList() {
			return GetRuleContext<ParameterListContext>(0);
		}
		public ErrorTaskDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_errorTaskDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterErrorTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitErrorTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitErrorTaskDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ErrorTaskDeclarationContext errorTaskDeclaration() {
		ErrorTaskDeclarationContext _localctx = new ErrorTaskDeclarationContext(Context, State);
		EnterRule(_localctx, 32, RULE_errorTaskDeclaration);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 176;
			Match(KW_ERRORTASK);
			State = 177;
			Match(IDENTIFIER);
			State = 178;
			Match(LPAREN);
			State = 180;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 16515072L) != 0)) {
				{
				State = 179;
				parameterList();
				}
			}

			State = 182;
			Match(RPAREN);
			State = 183;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class WaitTaskDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_WAITTASK() { return GetToken(StateMachineParser.KW_WAITTASK, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LBRACE() { return GetToken(StateMachineParser.LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public WaitTaskBodyContext waitTaskBody() {
			return GetRuleContext<WaitTaskBodyContext>(0);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RBRACE() { return GetToken(StateMachineParser.RBRACE, 0); }
		public WaitTaskDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_waitTaskDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterWaitTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitWaitTaskDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitWaitTaskDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public WaitTaskDeclarationContext waitTaskDeclaration() {
		WaitTaskDeclarationContext _localctx = new WaitTaskDeclarationContext(Context, State);
		EnterRule(_localctx, 34, RULE_waitTaskDeclaration);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 185;
			Match(KW_WAITTASK);
			State = 186;
			Match(IDENTIFIER);
			State = 187;
			Match(LBRACE);
			State = 188;
			waitTaskBody();
			State = 189;
			Match(RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class SubStateMachineTaskBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public InParametersSectionContext[] inParametersSection() {
			return GetRuleContexts<InParametersSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public InParametersSectionContext inParametersSection(int i) {
			return GetRuleContext<InParametersSectionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public OutParametersSectionContext[] outParametersSection() {
			return GetRuleContexts<OutParametersSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public OutParametersSectionContext outParametersSection(int i) {
			return GetRuleContext<OutParametersSectionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public UsingStateMachineSectionContext[] usingStateMachineSection() {
			return GetRuleContexts<UsingStateMachineSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public UsingStateMachineSectionContext usingStateMachineSection(int i) {
			return GetRuleContext<UsingStateMachineSectionContext>(i);
		}
		public SubStateMachineTaskBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_subStateMachineTaskBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterSubStateMachineTaskBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitSubStateMachineTaskBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitSubStateMachineTaskBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public SubStateMachineTaskBodyContext subStateMachineTaskBody() {
		SubStateMachineTaskBodyContext _localctx = new SubStateMachineTaskBodyContext(Context, State);
		EnterRule(_localctx, 36, RULE_subStateMachineTaskBody);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 196;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 14336L) != 0)) {
				{
				State = 194;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case KW_IN:
					{
					State = 191;
					inParametersSection();
					}
					break;
				case KW_OUT:
					{
					State = 192;
					outParametersSection();
					}
					break;
				case KW_USING:
					{
					State = 193;
					usingStateMachineSection();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 198;
				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 TaskBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclarationSectionContext[] eventDeclarationSection() {
			return GetRuleContexts<EventDeclarationSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclarationSectionContext eventDeclarationSection(int i) {
			return GetRuleContext<EventDeclarationSectionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ScriptSectionContext[] scriptSection() {
			return GetRuleContexts<ScriptSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public ScriptSectionContext scriptSection(int i) {
			return GetRuleContext<ScriptSectionContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public RawScriptSectionContext[] rawScriptSection() {
			return GetRuleContexts<RawScriptSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public RawScriptSectionContext rawScriptSection(int i) {
			return GetRuleContext<RawScriptSectionContext>(i);
		}
		public TaskBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_taskBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterTaskBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitTaskBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTaskBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TaskBodyContext taskBody() {
		TaskBodyContext _localctx = new TaskBodyContext(Context, State);
		EnterRule(_localctx, 38, RULE_taskBody);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 204;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 99328L) != 0)) {
				{
				State = 202;
				ErrorHandler.Sync(this);
				switch (TokenStream.LA(1)) {
				case KW_EVENT:
					{
					State = 199;
					eventDeclarationSection();
					}
					break;
				case KW_SCRIPT:
					{
					State = 200;
					scriptSection();
					}
					break;
				case KW_PAYLOAD_LBRACE:
					{
					State = 201;
					rawScriptSection();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				State = 206;
				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 WaitTaskBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclarationSectionContext[] eventDeclarationSection() {
			return GetRuleContexts<EventDeclarationSectionContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public EventDeclarationSectionContext eventDeclarationSection(int i) {
			return GetRuleContext<EventDeclarationSectionContext>(i);
		}
		public WaitTaskBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_waitTaskBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterWaitTaskBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitWaitTaskBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitWaitTaskBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public WaitTaskBodyContext waitTaskBody() {
		WaitTaskBodyContext _localctx = new WaitTaskBodyContext(Context, State);
		EnterRule(_localctx, 40, RULE_waitTaskBody);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 210;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==KW_EVENT) {
				{
				{
				State = 207;
				eventDeclarationSection();
				}
				}
				State = 212;
				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 EventDeclarationSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_EVENT() { return GetToken(StateMachineParser.KW_EVENT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(StateMachineParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(StateMachineParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ParameterListContext parameterList() {
			return GetRuleContext<ParameterListContext>(0);
		}
		public EventDeclarationSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_eventDeclarationSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterEventDeclarationSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitEventDeclarationSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitEventDeclarationSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public EventDeclarationSectionContext eventDeclarationSection() {
		EventDeclarationSectionContext _localctx = new EventDeclarationSectionContext(Context, State);
		EnterRule(_localctx, 42, RULE_eventDeclarationSection);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 213;
			Match(KW_EVENT);
			State = 214;
			Match(IDENTIFIER);
			State = 215;
			Match(LPAREN);
			State = 217;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 16515072L) != 0)) {
				{
				State = 216;
				parameterList();
				}
			}

			State = 219;
			Match(RPAREN);
			State = 220;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InParametersSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_IN() { return GetToken(StateMachineParser.KW_IN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(StateMachineParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public InParameterMappingContext[] inParameterMapping() {
			return GetRuleContexts<InParameterMappingContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public InParameterMappingContext inParameterMapping(int i) {
			return GetRuleContext<InParameterMappingContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(StateMachineParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(StateMachineParser.COMMA); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) {
			return GetToken(StateMachineParser.COMMA, i);
		}
		public InParametersSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_inParametersSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterInParametersSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitInParametersSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInParametersSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InParametersSectionContext inParametersSection() {
		InParametersSectionContext _localctx = new InParametersSectionContext(Context, State);
		EnterRule(_localctx, 44, RULE_inParametersSection);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 222;
			Match(KW_IN);
			State = 223;
			Match(LPAREN);
			State = 224;
			inParameterMapping();
			State = 229;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMA) {
				{
				{
				State = 225;
				Match(COMMA);
				State = 226;
				inParameterMapping();
				}
				}
				State = 231;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 232;
			Match(RPAREN);
			State = 233;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class InParameterMappingContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(StateMachineParser.IDENTIFIER); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) {
			return GetToken(StateMachineParser.IDENTIFIER, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode DARROW() { return GetToken(StateMachineParser.DARROW, 0); }
		public InParameterMappingContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_inParameterMapping; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterInParameterMapping(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitInParameterMapping(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitInParameterMapping(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public InParameterMappingContext inParameterMapping() {
		InParameterMappingContext _localctx = new InParameterMappingContext(Context, State);
		EnterRule(_localctx, 46, RULE_inParameterMapping);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 235;
			Match(IDENTIFIER);
			State = 236;
			Match(DARROW);
			State = 237;
			Match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class OutParametersSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_OUT() { return GetToken(StateMachineParser.KW_OUT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode LPAREN() { return GetToken(StateMachineParser.LPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public OutParameterMappingContext[] outParameterMapping() {
			return GetRuleContexts<OutParameterMappingContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public OutParameterMappingContext outParameterMapping(int i) {
			return GetRuleContext<OutParameterMappingContext>(i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RPAREN() { return GetToken(StateMachineParser.RPAREN, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] COMMA() { return GetTokens(StateMachineParser.COMMA); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode COMMA(int i) {
			return GetToken(StateMachineParser.COMMA, i);
		}
		public OutParametersSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_outParametersSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterOutParametersSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitOutParametersSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitOutParametersSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public OutParametersSectionContext outParametersSection() {
		OutParametersSectionContext _localctx = new OutParametersSectionContext(Context, State);
		EnterRule(_localctx, 48, RULE_outParametersSection);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 239;
			Match(KW_OUT);
			State = 240;
			Match(LPAREN);
			State = 241;
			outParameterMapping();
			State = 246;
			ErrorHandler.Sync(this);
			_la = TokenStream.LA(1);
			while (_la==COMMA) {
				{
				{
				State = 242;
				Match(COMMA);
				State = 243;
				outParameterMapping();
				}
				}
				State = 248;
				ErrorHandler.Sync(this);
				_la = TokenStream.LA(1);
			}
			State = 249;
			Match(RPAREN);
			State = 250;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class OutParameterMappingContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(StateMachineParser.IDENTIFIER); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) {
			return GetToken(StateMachineParser.IDENTIFIER, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARROW() { return GetToken(StateMachineParser.ARROW, 0); }
		public OutParameterMappingContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_outParameterMapping; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterOutParameterMapping(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitOutParameterMapping(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitOutParameterMapping(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public OutParameterMappingContext outParameterMapping() {
		OutParameterMappingContext _localctx = new OutParameterMappingContext(Context, State);
		EnterRule(_localctx, 50, RULE_outParameterMapping);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 252;
			Match(IDENTIFIER);
			State = 253;
			Match(ARROW);
			State = 254;
			Match(IDENTIFIER);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class UsingStateMachineSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_USING() { return GetToken(StateMachineParser.KW_USING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER() { return GetToken(StateMachineParser.IDENTIFIER, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		public UsingStateMachineSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_usingStateMachineSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterUsingStateMachineSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitUsingStateMachineSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitUsingStateMachineSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public UsingStateMachineSectionContext usingStateMachineSection() {
		UsingStateMachineSectionContext _localctx = new UsingStateMachineSectionContext(Context, State);
		EnterRule(_localctx, 52, RULE_usingStateMachineSection);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 256;
			Match(KW_USING);
			State = 257;
			Match(IDENTIFIER);
			State = 258;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class ScriptSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_SCRIPT() { return GetToken(StateMachineParser.KW_SCRIPT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode GRN() { return GetToken(StateMachineParser.GRN, 0); }
		public ScriptSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_scriptSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterScriptSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitScriptSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitScriptSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public ScriptSectionContext scriptSection() {
		ScriptSectionContext _localctx = new ScriptSectionContext(Context, State);
		EnterRule(_localctx, 54, RULE_scriptSection);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 260;
			Match(KW_SCRIPT);
			State = 261;
			Match(GRN);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class RawScriptSectionContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_PAYLOAD_LBRACE() { return GetToken(StateMachineParser.KW_PAYLOAD_LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RAW_SCRIPT_RBRACE() { return GetToken(StateMachineParser.RAW_SCRIPT_RBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public RawScriptBodyContext[] rawScriptBody() {
			return GetRuleContexts<RawScriptBodyContext>();
		}
		[System.Diagnostics.DebuggerNonUserCode] public RawScriptBodyContext rawScriptBody(int i) {
			return GetRuleContext<RawScriptBodyContext>(i);
		}
		public RawScriptSectionContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_rawScriptSection; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterRawScriptSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitRawScriptSection(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitRawScriptSection(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public RawScriptSectionContext rawScriptSection() {
		RawScriptSectionContext _localctx = new RawScriptSectionContext(Context, State);
		EnterRule(_localctx, 56, RULE_rawScriptSection);
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 263;
			Match(KW_PAYLOAD_LBRACE);
			State = 265;
			ErrorHandler.Sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					State = 264;
					rawScriptBody();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 267;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,20,Context);
			} while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER );
			State = 269;
			Match(RAW_SCRIPT_RBRACE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class RawScriptBodyContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RAW_SCRIPT_LBRACE() { return GetToken(StateMachineParser.RAW_SCRIPT_LBRACE, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RAW_SCRIPT_TEXT() { return GetToken(StateMachineParser.RAW_SCRIPT_TEXT, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode RAW_SCRIPT_RBRACE() { return GetToken(StateMachineParser.RAW_SCRIPT_RBRACE, 0); }
		public RawScriptBodyContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_rawScriptBody; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterRawScriptBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitRawScriptBody(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitRawScriptBody(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public RawScriptBodyContext rawScriptBody() {
		RawScriptBodyContext _localctx = new RawScriptBodyContext(Context, State);
		EnterRule(_localctx, 58, RULE_rawScriptBody);
		int _la;
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 271;
			_la = TokenStream.LA(1);
			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 481036337152L) != 0)) ) {
			ErrorHandler.RecoverInline(this);
			}
			else {
				ErrorHandler.ReportMatch(this);
			    Consume();
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

	public partial class TransitionDeclarationContext : ParserRuleContext {
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_TRANSITION() { return GetToken(StateMachineParser.KW_TRANSITION, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode[] IDENTIFIER() { return GetTokens(StateMachineParser.IDENTIFIER); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode IDENTIFIER(int i) {
			return GetToken(StateMachineParser.IDENTIFIER, i);
		}
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode KW_HANDLING() { return GetToken(StateMachineParser.KW_HANDLING, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode ARROW() { return GetToken(StateMachineParser.ARROW, 0); }
		[System.Diagnostics.DebuggerNonUserCode] public ITerminalNode SEMI() { return GetToken(StateMachineParser.SEMI, 0); }
		public TransitionDeclarationContext(ParserRuleContext parent, int invokingState)
			: base(parent, invokingState)
		{
		}
		public override int RuleIndex { get { return RULE_transitionDeclaration; } }
		[System.Diagnostics.DebuggerNonUserCode]
		public override void EnterRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.EnterTransitionDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override void ExitRule(IParseTreeListener listener) {
			IStateMachineParserListener typedListener = listener as IStateMachineParserListener;
			if (typedListener != null) typedListener.ExitTransitionDeclaration(this);
		}
		[System.Diagnostics.DebuggerNonUserCode]
		public override TResult Accept<TResult>(IParseTreeVisitor<TResult> visitor) {
			IStateMachineParserVisitor<TResult> typedVisitor = visitor as IStateMachineParserVisitor<TResult>;
			if (typedVisitor != null) return typedVisitor.VisitTransitionDeclaration(this);
			else return visitor.VisitChildren(this);
		}
	}

	[RuleVersion(0)]
	public TransitionDeclarationContext transitionDeclaration() {
		TransitionDeclarationContext _localctx = new TransitionDeclarationContext(Context, State);
		EnterRule(_localctx, 60, RULE_transitionDeclaration);
		try {
			EnterOuterAlt(_localctx, 1);
			{
			State = 273;
			Match(KW_TRANSITION);
			State = 274;
			Match(IDENTIFIER);
			State = 275;
			Match(KW_HANDLING);
			State = 276;
			Match(IDENTIFIER);
			State = 277;
			Match(ARROW);
			State = 278;
			Match(IDENTIFIER);
			State = 279;
			Match(SEMI);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}

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

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


}
} // namespace Gs2.Unity.Gs2StateMachine.Local.Parser